package com.wicket.okrapp.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.wicket.okrapp.base.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.req.ImplementComReqDto;
import com.wicket.okrapp.biz.service.dto.res.*;
import com.wicket.okrapp.biz.service.dto.res.ImplementComRespDto;
import com.wicket.okrapp.common.exception.BizException;
import com.wicket.okrapp.common.util.CommonFunctionHelper;
import com.wicket.okrapp.common.util.RedisUtil;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Resource;

import com.wicket.okrcalc.integration.dto.*;
import com.wicket.okrcalc.integration.dto.QueryStandardDataDetailComReqDto;
import com.wicket.okrcalc.integration.dto.QueryStandardDataDetailComRespDto;
import com.wicket.okrcomponent.integration.dto.*;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.wicket.okrapp.base.service.MOmsExecuteCycleStageService;
import com.wicket.okrapp.dal.po.mbg.OmsExecuteCycleStage;
import com.wicket.okrapp.common.exception.Assert;
import com.wicket.okrcalc.integration.FwCalcStandardDataClient;
import com.wicket.okrapp.base.service.MOmsTspeCycleStageDataService;
import com.wicket.okrapp.dal.po.mbg.OmsTspeCycleStageData;
import com.wicket.okrapp.base.service.MOmsStandardDataResultService;
import java.util.ArrayList;

import cn.hutool.core.collection.CollectionUtil;
import com.wicket.okrapp.biz.service.TargetContentService;
import com.wicket.okrcalc.integration.FwCalcGridCalculateClient;
import com.wicket.okrapp.base.service.MOmsCycleService;
import com.wicket.okrapp.dal.po.mbg.OmsCycle;
import com.wicket.okrapp.base.service.MOmsEvaluationObjectTargetCycleService;
import com.wicket.okrapp.dal.po.mbg.OmsEvaluationObjectTargetCycle;
import com.wicket.okrapp.biz.service.nb.NbGridCalculate;
import com.wicket.okrcomponent.integration.FwCompInterfaceModeClient;
import com.wicket.okrapp.base.service.MOmsTaskService;
import com.wicket.okrapp.dal.po.mbg.OmsTask;
import com.wicket.okrcomponent.integration.FwCompDivineDataClient;
import com.wicket.okrapp.biz.service.TaskService;
import com.wicket.okrapp.biz.service.TargetCycleService;
import com.wicket.okrcomponent.integration.FwCompConfSchemeClient;
import com.wicket.okrapp.biz.service.dto.common.ExecuteCycleStageDto;
import com.wicket.okrapp.base.service.MOmsTargetTimingTaskDispatchService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetTimingTaskDispatch;
import com.wicket.okrapp.base.service.MOmsEvaBatchRelatedSetService;

import com.wicket.okrapp.biz.service.CycleStageDataService;
import com.wicket.okrcalc.integration.FwCalcCalculationRulesClient;
import com.wicket.okrapp.base.service.MOmsEvaluationTemplateService;
import com.wicket.okrapp.dal.po.mbg.OmsEvaluationTemplate;
import com.wicket.okrapp.base.service.MOmsTargetCategoryExtendService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetCategoryExtend;
import com.wicket.okrapp.base.service.MOmsTargetObjectivePlanExtendService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetObjectivePlanExtend;
import com.wicket.okrapp.biz.service.ExecuteProgressService;
import com.wicket.okrapp.biz.service.TaskGenService;
import com.wicket.okrapp.biz.service.ProgressPublicTechnicaCapacityService;
import com.wicket.okrapp.base.service.MOmsExecuteProgressService;
import com.wicket.okrframework.integration.dto.QueryAppDetailComRespDto;
import com.wicket.okrframework.integration.dto.QueryAppDetailComReqDto;
import com.wicket.okrframework.integration.FwBaseBaseClient;
import com.wicket.okrcomponent.integration.FwCompTemplateEngineClient;
import com.wicket.okrapp.biz.service.InterfaceModeService;
import com.wicket.okrapp.biz.service.IndexSystemService;
import com.wicket.okrapp.biz.service.ExecuteCycleService;
import com.wicket.okrapp.biz.service.MessageService;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class GridCalculateServiceImpl
  implements com.wicket.okrapp.biz.service.GridCalculateService {

  @Resource
  private RedisUtil redisUtil;
@Resource
  private MOmsExecuteCycleStageService mOmsExecuteCycleStageService;
@Resource
  private FwCalcStandardDataClient fwCalcStandardDataClient;
@Resource
  private MOmsTspeCycleStageDataService mOmsTspeCycleStageDataService;
@Resource
  private MOmsStandardDataResultService mOmsStandardDataResultService;
//@Resource
 //private undefinedService undefinedService;
@Resource
  private TargetContentService targetContentService;
@Resource
  private FwCalcGridCalculateClient fwCalcGridCalculateClient;
//@Resource
 //private MCustomFields3Service mCustomFields3Service;
@Resource
  private MOmsCycleService mOmsCycleService;
@Resource
  private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
@Resource
  private NbGridCalculate nbGridCalculate;
@Resource
  private FwCompInterfaceModeClient fwCompInterfaceModeClient;
@Resource
  private MOmsTaskService mOmsTaskService;
@Resource
  private FwCompDivineDataClient fwCompDivineDataClient;
@Resource
  private TaskService taskService;
@Resource
  private TargetCycleService targetCycleService;
@Resource
  private FwCompConfSchemeClient fwCompConfSchemeClient;
@Resource
  private MOmsTargetTimingTaskDispatchService mOmsTargetTimingTaskDispatchService;
@Resource
  private MOmsEvaBatchRelatedSetService mOmsEvaBatchRelatedSetService;
@Resource
  private CycleStageDataService cycleStageDataService;
@Resource
  private FwCalcCalculationRulesClient fwCalcCalculationRulesClient;
@Resource
  private MOmsEvaluationTemplateService mOmsEvaluationTemplateService;
@Resource
  private MOmsTargetCategoryExtendService mOmsTargetCategoryExtendService;
@Resource
  private MOmsTargetObjectivePlanExtendService mOmsTargetObjectivePlanExtendService;
@Resource
  private ExecuteProgressService executeProgressService;
@Resource
  private TaskGenService taskGenService;
@Resource
  private ProgressPublicTechnicaCapacityService progressPublicTechnicaCapacityService;
@Resource
  private MOmsExecuteProgressService mOmsExecuteProgressService;
@Resource
  private FwBaseBaseClient fwBaseBaseClient;
@Resource
  private FwCompTemplateEngineClient fwCompTemplateEngineClient;
@Resource
  private InterfaceModeService interfaceModeService;
@Resource
  private IndexSystemService indexSystemService;
@Resource
  private ExecuteCycleService executeCycleService;
@Resource
  private MessageService messageService;
/**
   * D3-获取过程中期标准数据(公共)[6463]
   * gen by moon at 7/4/2023, 6:22:42 PM
   */
  @Trace(operationName = "D3-获取过程中期标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ObtainMidProgressCycleStaDataComRespDto obtainMidProgressCycleStaDataCom(ObtainMidProgressCycleStaDataComReqDto reqDto){
    
      
      QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto_1 =null;
//virtualUsage 3-3-07查询执行周期阶段详情  39581
      OmsExecuteCycleStage omsExecuteCycleStage = null;
    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq.setIsProcessCycleStage("TRUE");//sourceId:887677_1_39581
queryExecuteCycleStageDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:887676_1_39581
if(reqDto!=null){
      queryExecuteCycleStageDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:887673_1_39581
queryExecuteCycleStageDetailReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:887674_1_39581
queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:887675_1_39581
    }
  
    /*3-3-07查询执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq.getCycleStartTime(),"D3-获取过程中期标准数据(公共)-3-3-07查询执行周期阶段详情-周期开始时间不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsProcessCycleStage(),"D3-获取过程中期标准数据(公共)-3-3-07查询执行周期阶段详情-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(),"D3-获取过程中期标准数据(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getSubjectLifeCycle(),"D3-获取过程中期标准数据(公共)-3-3-07查询执行周期阶段详情-主体生命周期不能为空",false);
      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
if((omsExecuteCycleStage != null )) {
        //if(3-3-07查询执行周期阶段详情.出参 值不等于空 )  39582
        
QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
    if(omsExecuteCycleStage !=null){
          QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto=new QueryStandardDataDetailComReqDto();
  queryStandardDataDetailComReqDto.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:887684_1_39583
queryStandardDataDetailComReqDto.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1077348_1_39583
queryStandardDataDetailComReqDto.setIsArchive("FALSE");//sourceId:887687_1_39583
queryStandardDataDetailComReqDto.setIsNewData("TRUE");//sourceId:887688_1_39583
queryStandardDataDetailComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:887689_1_39583
if(omsExecuteCycleStage!=null){
      queryStandardDataDetailComReqDto.setPeriodId(omsExecuteCycleStage.getCycleId());//SimpleFieldAssign//sourceId:887683_1_39583
    }
if(reqDto!=null){
      queryStandardDataDetailComReqDto.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:887685_1_39583
queryStandardDataDetailComReqDto.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:887686_1_39583
queryStandardDataDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:887690_1_39583
    }
  
    /*D4-1查标准数据详情(公共)[2695]   */
    Assert.isNull(queryStandardDataDetailComReqDto.getPeriodId(),"D3-获取过程中期标准数据(公共)-D4-1查标准数据详情(公共)-周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getTableTypeCode(),"D3-获取过程中期标准数据(公共)-D4-1查标准数据详情(公共)-归属内容表类型编码不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getEntityId(),"D3-获取过程中期标准数据(公共)-D4-1查标准数据详情(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getDataType(),"D3-获取过程中期标准数据(公共)-D4-1查标准数据详情(公共)-数据点类型不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getDataUsageSceneCode(),"D3-获取过程中期标准数据(公共)-D4-1查标准数据详情(公共)-数据业务场景不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getIsArchive(),"D3-获取过程中期标准数据(公共)-D4-1查标准数据详情(公共)-是否存档不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getIsNewData(),"D3-获取过程中期标准数据(公共)-D4-1查标准数据详情(公共)-是否归属周期最新数据不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentTypeCode(),"D3-获取过程中期标准数据(公共)-D4-1查标准数据详情(公共)-主题内容类型编码不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentId(),"D3-获取过程中期标准数据(公共)-D4-1查标准数据详情(公共)-主题内容ID不能为空",false);
      queryStandardDataDetailComRespDto = fwCalcStandardDataClient.queryStandardDataDetailCom(queryStandardDataDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      
      
      queryStandardDataDetailComRespDto_1 = queryStandardDataDetailComRespDto;
           }
      }
ObtainMidProgressCycleStaDataComRespDto retData = new ObtainMidProgressCycleStaDataComRespDto();
  if(queryStandardDataDetailComRespDto_1!=null){
      retData.setDataResultId(queryStandardDataDetailComRespDto_1.getDataResultId());//SimpleFieldAssign//sourceId:887695_1
retData.setDataResult(queryStandardDataDetailComRespDto_1.getDataResult());//SimpleFieldAssign//sourceId:887696_1
    }
  

  
  
return retData;
  }

/**
   * D3-分析目标周期是否满足托底计算(公共)[6502]
   * gen by moon at 10/15/2023, 3:36:02 AM
   */
  @Trace(operationName = "D3-分析目标周期是否满足托底计算(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTargetCycleCanExecuteUnderpinningCalcComRespDto implementTargetCycleCanExecuteUnderpinningCalcCom(ImplementTargetCycleCanExecuteUnderpinningCalcComReqDto reqDto){


      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1 =null;
CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 =null;
//virtualUsage 满足循环发牌  40241
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq.setTureOrFalse("TRUE");//sourceId:901452_1_40241

    /*满足循环发牌[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq);



//virtualUsage 不满足循环发牌  40242
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_1.setTureOrFalse("FALSE");//sourceId:901454_1_40242

    /*不满足循环发牌[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);



//virtualUsage D3获取当前目标内容执行周期(公共)  49703
      ObtainCurrentTargetContexeCuteCycleComRespDto obtainCurrentTargetContexeCuteCycleComRespDto = null;
    ObtainCurrentTargetContexeCuteCycleComReqDto obtainCurrentTargetContexeCuteCycleComReqDto=new ObtainCurrentTargetContexeCuteCycleComReqDto();
  if(reqDto!=null){
      obtainCurrentTargetContexeCuteCycleComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1163348_1_49703
obtainCurrentTargetContexeCuteCycleComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1163349_1_49703
obtainCurrentTargetContexeCuteCycleComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1163350_1_49703
obtainCurrentTargetContexeCuteCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1163351_1_49703
    }

    /*D3获取当前目标内容执行周期(公共)[7501]   */
    Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getCycleId(),"D3-分析目标周期是否满足托底计算(公共)-D3获取当前目标内容执行周期(公共)-周期ID不能为空",false);
Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getTargetCycleContentId(),"D3-分析目标周期是否满足托底计算(公共)-D3获取当前目标内容执行周期(公共)-关联目标内容ID不能为空",false);
Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getTargetId(),"D3-分析目标周期是否满足托底计算(公共)-D3获取当前目标内容执行周期(公共)-冗余目标ID不能为空",false);
Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getEvaluationTemplateId(),"D3-分析目标周期是否满足托底计算(公共)-D3获取当前目标内容执行周期(公共)-冗余评价模板ID不能为空",false);
      obtainCurrentTargetContexeCuteCycleComRespDto = executeCycleService.obtainCurrentTargetContexeCuteCycleCom(obtainCurrentTargetContexeCuteCycleComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage 3-3-09查被评对象目标周期详情  40236
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    if(obtainCurrentTargetContexeCuteCycleComRespDto !=null){
          QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:901418_1_40236
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:901421_1_40236
    }
if(obtainCurrentTargetContexeCuteCycleComRespDto!=null){
      queryEvaObjTargetCycleDetailReq.setCycleStartTime(obtainCurrentTargetContexeCuteCycleComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:901419_1_40236
queryEvaObjTargetCycleDetailReq.setCycleEndTime(obtainCurrentTargetContexeCuteCycleComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:901420_1_40236
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3-分析目标周期是否满足托底计算(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getCycleStartTime(),"D3-分析目标周期是否满足托底计算(公共)-3-3-09查被评对象目标周期详情-目标计划开始时间不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getCycleEndTime(),"D3-分析目标周期是否满足托底计算(公共)-3-3-09查被评对象目标周期详情-目标计划结束时间不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-分析目标周期是否满足托底计算(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsEvaluationObjectTargetCycle_1 = omsEvaluationObjectTargetCycle;
           }
if((omsEvaluationObjectTargetCycle != null )) {
        //if(3-3-09查目标周期详情（根据周期时间范围查询目标周期牌是否满足）.出参 值不等于空 )  40237

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_2=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setTureOrFalse(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:901467_1_40238
    }

    /*约定出参：是否满足循环发牌[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getTureOrFalse(),"D3-分析目标周期是否满足托底计算(公共)-约定出参：是否满足循环发牌-是否不能为空",false);
      receptionServiceRes_4 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_2);


      receptionServiceRes_5 = receptionServiceRes_4;
      }
else if((omsEvaluationObjectTargetCycle == null )){
       //elseif(3-3-09查目标周期详情（根据周期时间范围查询目标周期牌是否满足）.出参 值等于空 )  40239

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_3=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_3.setTureOrFalse(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:901467_1_40240
    }

    /*约定出参：是否满足循环发牌[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getTureOrFalse(),"D3-分析目标周期是否满足托底计算(公共)-约定出参：是否满足循环发牌-是否不能为空",false);
      receptionServiceRes_6 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_3);


      receptionServiceRes_5 = receptionServiceRes_6;
    }
ImplementTargetCycleCanExecuteUnderpinningCalcComRespDto retData = new ImplementTargetCycleCanExecuteUnderpinningCalcComRespDto();
  if(receptionServiceRes_5!=null){
      retData.setTureOrFalse(receptionServiceRes_5.getTureOrFalse());//SimpleFieldAssign//sourceId:901485_1
    }
if(omsEvaluationObjectTargetCycle_1!=null){
      retData.setHaveProcessCycle(omsEvaluationObjectTargetCycle_1.getHaveProcessCycle());//SimpleFieldAssign//sourceId:901790_1
    }




return retData;
  }


/**
   * D3-执行自动汇报处理(公共)[6524]
   * gen by moon at 5/9/2023, 5:48:37 AM
   */
  @Trace(operationName = "D3-执行自动汇报处理(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAutoReportComRespDto implementAutoReportCom(ImplementAutoReportComReqDto reqDto){


      //virtualUsage 3-7-01查询任务详情  40535
      OmsTask omsTask = null;
    QueryTaskDetailReq queryTaskDetailReq=new QueryTaskDetailReq();
  queryTaskDetailReq.setIsComplete("FALSE");//sourceId:904285_1_40535
queryTaskDetailReq.setIsAutoReport("TRUE");//sourceId:904284_1_40535
if(reqDto!=null){
      queryTaskDetailReq.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:904274_1_40535
queryTaskDetailReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:904275_1_40535
    }

    /*3-7-01查询任务详情[2522]   */
    Assert.isNull(queryTaskDetailReq.getTaskId(),"D3-执行自动汇报处理(公共)-3-7-01查询任务详情-任务ID不能为空",false);
Assert.isNull(queryTaskDetailReq.getIsComplete(),"D3-执行自动汇报处理(公共)-3-7-01查询任务详情-是否完成不能为空",false);
Assert.isNull(queryTaskDetailReq.getIsAutoReport(),"D3-执行自动汇报处理(公共)-3-7-01查询任务详情-是否自动汇报不能为空",false);
Assert.isNull(queryTaskDetailReq.getThemeContentId(),"D3-执行自动汇报处理(公共)-3-7-01查询任务详情-主题内容ID不能为空",false);
      omsTask = mOmsTaskService.queryTaskDetail(queryTaskDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsTask != null )) {
        //if(3-7-01查任务是否未完成且是自动汇报.出参 值不等于空 )  40536

CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
    if(omsTask !=null){
          CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto=new CheckTimeScopeSearchComReqDto();
  checkTimeScopeSearchComReqDto.setCurrentTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:904286_1_40537
if(omsTask!=null){
      checkTimeScopeSearchComReqDto.setCompareTime(omsTask.getPlanEndTime());//SimpleFieldAssign//sourceId:904288_1_40537
    }

    /*D2检查时间范围查询(公共)[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(),"D3-执行自动汇报处理(公共)-D2检查时间范围查询(公共)-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(),"D3-执行自动汇报处理(公共)-D2检查时间范围查询(公共)-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT")||checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("LATER"))) {
        //if((D2-当前时间与任务结束时间比较.时间比较结果 等于 当前（等于） or D2-当前时间与任务结束时间比较.时间比较结果 等于 之后（大于）))  40538

ImplementAnalysisIsPlanReceptionCycleComRespDto implementAnalysisIsPlanReceptionCycleComRespDto = null;
    ImplementAnalysisIsPlanReceptionCycleComReqDto implementAnalysisIsPlanReceptionCycleComReqDto=new ImplementAnalysisIsPlanReceptionCycleComReqDto();
  if(reqDto!=null){
      implementAnalysisIsPlanReceptionCycleComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:904289_1_40542
implementAnalysisIsPlanReceptionCycleComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:904290_1_40542
implementAnalysisIsPlanReceptionCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:904291_1_40542
    }

    /*D3-执行分析当前是否验收周期(公共)[6139]   */
    Assert.isNull(implementAnalysisIsPlanReceptionCycleComReqDto.getEvaObjTargetCycleId(),"D3-执行自动汇报处理(公共)-D3-执行分析当前是否验收周期(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementAnalysisIsPlanReceptionCycleComReqDto.getCycleId(),"D3-执行自动汇报处理(公共)-D3-执行分析当前是否验收周期(公共)-周期ID不能为空",false);
Assert.isNull(implementAnalysisIsPlanReceptionCycleComReqDto.getEvaluationTemplateId(),"D3-执行自动汇报处理(公共)-D3-执行分析当前是否验收周期(公共)-冗余评价模板ID不能为空",false);
      implementAnalysisIsPlanReceptionCycleComRespDto = targetContentService.implementAnalysisIsPlanReceptionCycleCom(implementAnalysisIsPlanReceptionCycleComReqDto)/*vcase invoke isSameApp*/;



ImplementReportingTaskInfoComRespDto implementReportingTaskInfoComRespDto = null;
    if(implementAnalysisIsPlanReceptionCycleComRespDto !=null){
          ImplementReportingTaskInfoComReqDto implementReportingTaskInfoComReqDto=new ImplementReportingTaskInfoComReqDto();
  implementReportingTaskInfoComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:904188_1_40540
if(reqDto!=null){
      implementReportingTaskInfoComReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:904193_1_40540
implementReportingTaskInfoComReqDto.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:904187_1_40540
implementReportingTaskInfoComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:904190_1_40540
implementReportingTaskInfoComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:904191_1_40540
implementReportingTaskInfoComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:904189_1_40540
    }
if(implementAnalysisIsPlanReceptionCycleComRespDto!=null){
      implementReportingTaskInfoComReqDto.setIsActualReceptionCycle(implementAnalysisIsPlanReceptionCycleComRespDto.getIsPlanReceptionCycle());//SimpleFieldAssign//sourceId:904192_1_40540
    }

    /*D3-执行汇报任务资料正式提交处理(公共)[5489]   */
    Assert.isNull(implementReportingTaskInfoComReqDto.getCycleStageDataId(),"D3-执行自动汇报处理(公共)-D3-执行汇报任务资料正式提交处理(公共)-周期阶段资料记录ID不能为空",false);
Assert.isNull(implementReportingTaskInfoComReqDto.getTaskId(),"D3-执行自动汇报处理(公共)-D3-执行汇报任务资料正式提交处理(公共)-任务ID不能为空",false);
Assert.isNull(implementReportingTaskInfoComReqDto.getEvaObjTargetCycleId(),"D3-执行自动汇报处理(公共)-D3-执行汇报任务资料正式提交处理(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementReportingTaskInfoComReqDto.getCycleId(),"D3-执行自动汇报处理(公共)-D3-执行汇报任务资料正式提交处理(公共)-周期ID不能为空",false);
Assert.isNull(implementReportingTaskInfoComReqDto.getSubjectLifeCycle(),"D3-执行自动汇报处理(公共)-D3-执行汇报任务资料正式提交处理(公共)-主体生命周期不能为空",false);
Assert.isNull(implementReportingTaskInfoComReqDto.getEvaluationTemplateId(),"D3-执行自动汇报处理(公共)-D3-执行汇报任务资料正式提交处理(公共)-冗余评价模板ID不能为空",false);
      implementReportingTaskInfoComRespDto = taskService.implementReportingTaskInfoCom(implementReportingTaskInfoComReqDto)/*vcase invoke isSameApp*/;



           }
UpdateEvaObjTargetCycleComRespDto updateEvaObjTargetCycleComRespDto = null;
    UpdateEvaObjTargetCycleComReqDto updateEvaObjTargetCycleComReqDto=new UpdateEvaObjTargetCycleComReqDto();
  if(reqDto!=null){
      updateEvaObjTargetCycleComReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:904201_1_40541
updateEvaObjTargetCycleComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:904199_1_40541
updateEvaObjTargetCycleComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:904204_1_40541
updateEvaObjTargetCycleComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:904202_1_40541
updateEvaObjTargetCycleComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:904203_1_40541
updateEvaObjTargetCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:904200_1_40541
    }

    /*D3-3修改被评对象目标周期进展状态(公共)[3910]   */
    Assert.isNull(updateEvaObjTargetCycleComReqDto.getCycleStageDataId(),"D3-执行自动汇报处理(公共)-D3-3修改被评对象目标周期进展状态(公共)-周期阶段资料记录ID不能为空",false);
Assert.isNull(updateEvaObjTargetCycleComReqDto.getEvaObjTargetCycleId(),"D3-执行自动汇报处理(公共)-D3-3修改被评对象目标周期进展状态(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(updateEvaObjTargetCycleComReqDto.getCycleId(),"D3-执行自动汇报处理(公共)-D3-3修改被评对象目标周期进展状态(公共)-周期ID不能为空",false);
Assert.isNull(updateEvaObjTargetCycleComReqDto.getTargetCycleContentTypeCode(),"D3-执行自动汇报处理(公共)-D3-3修改被评对象目标周期进展状态(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(updateEvaObjTargetCycleComReqDto.getTargetCycleContentId(),"D3-执行自动汇报处理(公共)-D3-3修改被评对象目标周期进展状态(公共)-关联目标内容ID不能为空",false);
Assert.isNull(updateEvaObjTargetCycleComReqDto.getEvaluationTemplateId(),"D3-执行自动汇报处理(公共)-D3-3修改被评对象目标周期进展状态(公共)-冗余评价模板ID不能为空",false);
      updateEvaObjTargetCycleComRespDto = targetCycleService.updateEvaObjTargetCycleCom(updateEvaObjTargetCycleComReqDto)/*vcase invoke isSameApp*/;



      }
      }
ImplementAutoReportComRespDto retData = new ImplementAutoReportComRespDto();





return retData;
  }
/**
   * D3-执行回写是否自动汇报(公共)[6541]
   * gen by moon at 4/24/2024, 4:07:31 PM
   */
  @Trace(operationName = "D3-执行回写是否自动汇报(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementWriteBackTaskAutoReportComRespDto implementWriteBackTaskAutoReportCom(ImplementWriteBackTaskAutoReportComReqDto reqDto){


      //virtualUsage D3-执行标准数据计算周期模型分析(公共)  40802
      ImplementCurrentCycleTypeAnalysisNoCalcComRespDto implementCurrentCycleTypeAnalysisNoCalcComRespDto = null;
    ImplementCurrentCycleTypeAnalysisNoCalcComReqDto implementCurrentCycleTypeAnalysisNoCalcComReqDto=new ImplementCurrentCycleTypeAnalysisNoCalcComReqDto();
  if(reqDto!=null){
      implementCurrentCycleTypeAnalysisNoCalcComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1028747_1_40802
implementCurrentCycleTypeAnalysisNoCalcComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1028748_1_40802
      implementCurrentCycleTypeAnalysisNoCalcComReqDto.setCurrentCycleType(reqDto.getCurrentCycleType());//SimpleFieldAssign//sourceId:914886_1_40802
implementCurrentCycleTypeAnalysisNoCalcComReqDto.setLastCycleType(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:914887_1_40802
implementCurrentCycleTypeAnalysisNoCalcComReqDto.setIsFatherCycle(reqDto.getIsFatherCycle());//SimpleFieldAssign//sourceId:1006774_1_40802
implementCurrentCycleTypeAnalysisNoCalcComReqDto.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1006776_1_40802
implementCurrentCycleTypeAnalysisNoCalcComReqDto.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1006775_1_40802
implementCurrentCycleTypeAnalysisNoCalcComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1028749_1_40802
    }

    /*D3-执行标准数据计算周期模型分析(公共)[6546]   */
    Assert.isNull(implementCurrentCycleTypeAnalysisNoCalcComReqDto.getEvaObjTargetCycleId(),"D3-执行回写是否自动汇报(公共)-D3-执行标准数据计算周期模型分析(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementCurrentCycleTypeAnalysisNoCalcComReqDto.getCycleId(),"D3-执行回写是否自动汇报(公共)-D3-执行标准数据计算周期模型分析(公共)-周期ID不能为空",false);
    Assert.isNull(implementCurrentCycleTypeAnalysisNoCalcComReqDto.getCurrentCycleType(),"D3-执行回写是否自动汇报(公共)-D3-执行标准数据计算周期模型分析(公共)-当前周期类型不能为空",false);
Assert.isNull(implementCurrentCycleTypeAnalysisNoCalcComReqDto.getIsFatherCycle(),"D3-执行回写是否自动汇报(公共)-D3-执行标准数据计算周期模型分析(公共)-是否父周期不能为空",false);
Assert.isNull(implementCurrentCycleTypeAnalysisNoCalcComReqDto.getIsMetaphase(),"D3-执行回写是否自动汇报(公共)-D3-执行标准数据计算周期模型分析(公共)-是否中期不能为空",false);
Assert.isNull(implementCurrentCycleTypeAnalysisNoCalcComReqDto.getIsSubCycle(),"D3-执行回写是否自动汇报(公共)-D3-执行标准数据计算周期模型分析(公共)-是否子周期不能为空",false);
Assert.isNull(implementCurrentCycleTypeAnalysisNoCalcComReqDto.getEvaluationTemplateId(),"D3-执行回写是否自动汇报(公共)-D3-执行标准数据计算周期模型分析(公共)-冗余评价模板ID不能为空",false);
      implementCurrentCycleTypeAnalysisNoCalcComRespDto = implementCurrentCycleTypeAnalysisNoCalcCom(implementCurrentCycleTypeAnalysisNoCalcComReqDto)/*vcase invoke 同服务,同domain*/;



//virtualUsage D4-进度值人工汇报条件模型(公共)  40744
      ImplementProgressValueManualFormAnalysisComRespDto implementProgressValueManualFormAnalysisComRespDto = null;
    if(implementCurrentCycleTypeAnalysisNoCalcComRespDto !=null){
          ImplementProgressValueManualFormAnalysisComReqDto implementProgressValueManualFormAnalysisComReqDto=new ImplementProgressValueManualFormAnalysisComReqDto();
  if(reqDto!=null){
      implementProgressValueManualFormAnalysisComReqDto.setSchemeDataPara(reqDto.getSchemeDataPara());//SimpleFieldAssign//sourceId:913228_1_40744
implementProgressValueManualFormAnalysisComReqDto.setReportType(reqDto.getReportType());//SimpleFieldAssign//sourceId:913230_1_40744
implementProgressValueManualFormAnalysisComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:913229_1_40744
implementProgressValueManualFormAnalysisComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:913224_1_40744
implementProgressValueManualFormAnalysisComReqDto.setTargetValueType(reqDto.getTargetValueType());//SimpleFieldAssign//sourceId:913225_1_40744
implementProgressValueManualFormAnalysisComReqDto.setIsLastObjective(reqDto.getIsLastObjective());//SimpleFieldAssign//sourceId:913223_1_40744
implementProgressValueManualFormAnalysisComReqDto.setCalculateDataSource(reqDto.getCalculateDataSource());//SimpleFieldAssign//sourceId:913226_1_40744
    }
if(implementCurrentCycleTypeAnalysisNoCalcComRespDto!=null){
      implementProgressValueManualFormAnalysisComReqDto.setStandardDataCalcCycleModel(implementCurrentCycleTypeAnalysisNoCalcComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:913233_1_40744
    }

    /*D4-进度值人工汇报条件模型(公共)[6397]   */
    Assert.isNull(implementProgressValueManualFormAnalysisComReqDto.getSchemeDataPara(),"D3-执行回写是否自动汇报(公共)-D4-进度值人工汇报条件模型(公共)-评价模板商业参数不能为空",false);
Assert.isNull(implementProgressValueManualFormAnalysisComReqDto.getReportType(),"D3-执行回写是否自动汇报(公共)-D4-进度值人工汇报条件模型(公共)-汇报类型不能为空",false);
Assert.isNull(implementProgressValueManualFormAnalysisComReqDto.getEvaObjTypeCode(),"D3-执行回写是否自动汇报(公共)-D4-进度值人工汇报条件模型(公共)-被评对象类型编码不能为空",false);
Assert.isNull(implementProgressValueManualFormAnalysisComReqDto.getTargetCycleContentTypeCode(),"D3-执行回写是否自动汇报(公共)-D4-进度值人工汇报条件模型(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementProgressValueManualFormAnalysisComReqDto.getStandardDataCalcCycleModel(),"D3-执行回写是否自动汇报(公共)-D4-进度值人工汇报条件模型(公共)-标准数据计算周期模型不能为空",false);
      implementProgressValueManualFormAnalysisComRespDto = fwCalcGridCalculateClient.implementProgressValueManualFormAnalysisCom(implementProgressValueManualFormAnalysisComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//virtualUsage D4-实际值人工汇报条件模型(公共)  40745
      ImplementActualValueManualFormAnalysisComRespDto implementActualValueManualFormAnalysisComRespDto = null;
    if(implementCurrentCycleTypeAnalysisNoCalcComRespDto !=null){
          ImplementActualValueManualFormAnalysisComReqDto implementActualValueManualFormAnalysisComReqDto=new ImplementActualValueManualFormAnalysisComReqDto();
  if(reqDto!=null){
implementActualValueManualFormAnalysisComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:913235_1_40745
implementActualValueManualFormAnalysisComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:913236_1_40745
implementActualValueManualFormAnalysisComReqDto.setIsLastObjective(reqDto.getIsLastObjective());//SimpleFieldAssign//sourceId:913242_1_40745
implementActualValueManualFormAnalysisComReqDto.setTargetValueType(reqDto.getTargetValueType());//SimpleFieldAssign//sourceId:913237_1_40745
implementActualValueManualFormAnalysisComReqDto.setQuantityObjectiveNoValue(reqDto.getQuantityObjectiveNoValue());//SimpleFieldAssign//sourceId:913243_1_40745
implementActualValueManualFormAnalysisComReqDto.setCalculateDataSource(reqDto.getCalculateDataSource());//SimpleFieldAssign//sourceId:913238_1_40745
    }
if(implementCurrentCycleTypeAnalysisNoCalcComRespDto!=null){
      implementActualValueManualFormAnalysisComReqDto.setStandardDataCalcCycleModel(implementCurrentCycleTypeAnalysisNoCalcComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:913239_1_40745
    }

    /*D4-实际值人工汇报条件模型(公共)[6416]   */
Assert.isNull(implementActualValueManualFormAnalysisComReqDto.getEvaObjTypeCode(),"D3-执行回写是否自动汇报(公共)-D4-实际值人工汇报条件模型(公共)-被评对象类型编码不能为空",false);
Assert.isNull(implementActualValueManualFormAnalysisComReqDto.getTargetCycleContentTypeCode(),"D3-执行回写是否自动汇报(公共)-D4-实际值人工汇报条件模型(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementActualValueManualFormAnalysisComReqDto.getStandardDataCalcCycleModel(),"D3-执行回写是否自动汇报(公共)-D4-实际值人工汇报条件模型(公共)-标准数据计算周期模型不能为空",false);
      implementActualValueManualFormAnalysisComRespDto = fwCalcGridCalculateClient.implementActualValueManualFormAnalysisCom(implementActualValueManualFormAnalysisComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((reqDto!= null&&  reqDto.getReportType() !=null && reqDto.getReportType().equals("AUTO_REPORT"))||(reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY")&&reqDto!= null&&  reqDto.getConstTaskIsOpenReport() !=null && reqDto.getConstTaskIsOpenReport().equals("TRUE")&&reqDto!= null&&  reqDto.getConstIsOpenAtuoReport() !=null && reqDto.getConstIsOpenAtuoReport().equals("TRUE"))) {
        //if(D3-执行回写是否自动汇报(公共).汇报类型 等于 全自动汇报 or (D3-执行回写是否自动汇报(公共).关联目标内容类型编码 等于 目标分类 and D3-执行回写是否自动汇报(公共).建设任务是否开启汇报 等于 是 and D3-执行回写是否自动汇报(公共).建设任务是否自动汇报 等于 是))  44832

if((reqDto!= null&&  reqDto.getSchemeDataPara() !=null && reqDto.getSchemeDataPara().equals("DOC_TYPE"))) {
        //if(D3-执行回写是否自动汇报(公共).评价模板数据参数 等于 资料型)  44837

if((implementActualValueManualFormAnalysisComRespDto!= null&& implementActualValueManualFormAnalysisComRespDto.getActualValueCalcFormula() == null )) {
        //if(D4-分析实际值是否人工汇报.实际值计算公式 值等于空 )  44846

boolean bOOLEAN ;
    OmsTask omsTask=new OmsTask();
  omsTask.setIsAutoReport("TRUE");//sourceId:913567_1_44847
if(reqDto!=null){
      omsTask.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:913566_1_44847
    }

    /*3-7-01修改任务（修改为自动提交汇报）[2706]   */
    Assert.isNull(omsTask.getTaskId(),"D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为自动提交汇报）-任务ID不能为空",false);
Assert.isNull(omsTask.getIsAutoReport(),"D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为自动提交汇报）-是否自动汇报不能为空",false);
      bOOLEAN = mOmsTaskService.updateTask(omsTask)/*vcase invoke 本地 method 方法调用;*/;



if((reqDto!= null&&  reqDto.getTargetValueType() !=null && reqDto.getTargetValueType().equals("SUBJECTIVE_QUALITATIVE")||reqDto!= null&&  reqDto.getQuantityObjectiveNoValue() !=null && reqDto.getQuantityObjectiveNoValue().equals("TRUE"))) {
        //if((D3-执行回写是否自动汇报(公共).冗余指标业务类型 等于 主观定性 or D3-执行回写是否自动汇报(公共).数量型指标当无实际值标记 等于 是))  49723

boolean bOOLEAN_1 ;
    OmsTask omsTask_1=new OmsTask();
  omsTask_1.setIsAutoReport("FALSE");//sourceId:1163528_1_49724
if(reqDto!=null){
      omsTask_1.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1163527_1_49724
    }

    /*3-7-01修改任务（修改为非自动提交汇报）[2706]   */
    Assert.isNull(omsTask_1.getTaskId(),"D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为非自动提交汇报）-任务ID不能为空",false);
Assert.isNull(omsTask_1.getIsAutoReport(),"D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为非自动提交汇报）-是否自动汇报不能为空",false);
      bOOLEAN_1 = mOmsTaskService.updateTask(omsTask_1)/*vcase invoke 本地 method 方法调用;*/;



      }
      }
      }
else if((reqDto!= null&&  reqDto.getSchemeDataPara() !=null && reqDto.getSchemeDataPara().equals("PROCESS_TYPE"))){
       //elseif(D3-执行回写是否自动汇报(公共).评价模板数据参数 等于 进度型)  44842

if((implementProgressValueManualFormAnalysisComRespDto!= null&& implementProgressValueManualFormAnalysisComRespDto.getProgressValueCalcFormula() == null &&implementActualValueManualFormAnalysisComRespDto!= null&& implementActualValueManualFormAnalysisComRespDto.getActualValueCalcFormula() == null )) {
        //if((D4-分析进度值是否人工汇报.进度值计算公式 值等于空  and D4-分析实际值是否人工汇报.实际值计算公式 值等于空 ))  44849

boolean bOOLEAN_2 ;
    OmsTask omsTask_2=new OmsTask();
  omsTask_2.setIsAutoReport("TRUE");//sourceId:913567_1_44850
if(reqDto!=null){
      omsTask_2.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:913566_1_44850
    }

    /*3-7-01修改任务（修改为自动提交汇报）[2706]   */
    Assert.isNull(omsTask_2.getTaskId(),"D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为自动提交汇报）-任务ID不能为空",false);
Assert.isNull(omsTask_2.getIsAutoReport(),"D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为自动提交汇报）-是否自动汇报不能为空",false);
      bOOLEAN_2 = mOmsTaskService.updateTask(omsTask_2)/*vcase invoke 本地 method 方法调用;*/;



if((reqDto!= null&&  reqDto.getTargetValueType() !=null && reqDto.getTargetValueType().equals("SUBJECTIVE_QUALITATIVE")&&reqDto!= null&&  reqDto.getNoPracticalValueObjIsProgReport() !=null && reqDto.getNoPracticalValueObjIsProgReport().equals("TRUE")&&reqDto!= null&&  reqDto.getIsOkrPlanScene() !=null && reqDto.getIsOkrPlanScene().equals("NO_OKR_PLAN_SCENE")&&reqDto!= null&&  reqDto.getIndicatorKind() !=null && reqDto.getIndicatorKind().equals("OBJECTIVES")&&reqDto!= null&&  reqDto.getIsLastObjective() !=null && reqDto.getIsLastObjective().equals("TRUE"))) {
        //if((D3-执行回写是否自动汇报(公共).冗余指标业务类型 等于 主观定性 and D3-执行回写是否自动汇报(公共).无实际值指标是否开启进度汇报 等于 是 and D3-执行回写是否自动汇报(公共).冗余开启OKR场景 等于 无OKR场景 and D3-执行回写是否自动汇报(公共).OKR目标属性 等于 目标O and D3-执行回写是否自动汇报(公共).是否末级指标 等于 是))  49727

boolean bOOLEAN_3 ;
    OmsTask omsTask_3=new OmsTask();
  omsTask_3.setIsAutoReport("FALSE");//sourceId:1163528_1_49728
if(reqDto!=null){
      omsTask_3.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1163527_1_49728
    }

    /*3-7-01修改任务（修改为非自动提交汇报）[2706]   */
    Assert.isNull(omsTask_3.getTaskId(),"D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为非自动提交汇报）-任务ID不能为空",false);
Assert.isNull(omsTask_3.getIsAutoReport(),"D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为非自动提交汇报）-是否自动汇报不能为空",false);
      bOOLEAN_3 = mOmsTaskService.updateTask(omsTask_3)/*vcase invoke 本地 method 方法调用;*/;



      }
      }
    }
else if((reqDto!= null&&  reqDto.getSchemeDataPara() !=null && reqDto.getSchemeDataPara().equals("REACH_TYPE"))){
       //elseif(D3-执行回写是否自动汇报(公共).评价模板数据参数 等于 达成度型)  44843

if((implementActualValueManualFormAnalysisComRespDto!= null&& implementActualValueManualFormAnalysisComRespDto.getActualValueCalcFormula() == null &&reqDto!= null&&  reqDto.getIsSubjectiveScoring() !=null && reqDto.getIsSubjectiveScoring().equals("FALSE"))) {
        //if((D4-分析实际值是否人工汇报.实际值计算公式 值等于空  and D3-执行回写是否自动汇报(公共).是否开启主观评分 等于 否))  44852

boolean bOOLEAN_4 ;
    OmsTask omsTask_4=new OmsTask();
  omsTask_4.setIsAutoReport("TRUE");//sourceId:913567_1_44874
if(reqDto!=null){
      omsTask_4.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:913566_1_44874
    }

    /*3-7-01修改任务（修改为自动提交汇报）[2706]   */
    Assert.isNull(omsTask_4.getTaskId(),"D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为自动提交汇报）-任务ID不能为空",false);
Assert.isNull(omsTask_4.getIsAutoReport(),"D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为自动提交汇报）-是否自动汇报不能为空",false);
      bOOLEAN_4 = mOmsTaskService.updateTask(omsTask_4)/*vcase invoke 本地 method 方法调用;*/;



if((reqDto!= null&&  reqDto.getTargetValueType() !=null && reqDto.getTargetValueType().equals("SUBJECTIVE_QUALITATIVE")||reqDto!= null&&  reqDto.getQuantityObjectiveNoValue() !=null && reqDto.getQuantityObjectiveNoValue().equals("TRUE"))) {
        //if((D3-执行回写是否自动汇报(公共).冗余指标业务类型 等于 主观定性 or D3-执行回写是否自动汇报(公共).数量型指标当无实际值标记 等于 是))  49725

boolean bOOLEAN_5 ;
    OmsTask omsTask_5=new OmsTask();
  omsTask_5.setIsAutoReport("FALSE");//sourceId:1163528_1_49726
if(reqDto!=null){
      omsTask_5.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1163527_1_49726
    }

    /*3-7-01修改任务（修改为非自动提交汇报）[2706]   */
    Assert.isNull(omsTask_5.getTaskId(),"D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为非自动提交汇报）-任务ID不能为空",false);
Assert.isNull(omsTask_5.getIsAutoReport(),"D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为非自动提交汇报）-是否自动汇报不能为空",false);
      bOOLEAN_5 = mOmsTaskService.updateTask(omsTask_5)/*vcase invoke 本地 method 方法调用;*/;



      }
      }
    }
else if((reqDto!= null&&  reqDto.getSchemeDataPara() !=null && reqDto.getSchemeDataPara().equals("MIXED_TYPE"))){
       //elseif(D3-执行回写是否自动汇报(公共).评价模板数据参数 等于 混合型)  44844

if((implementProgressValueManualFormAnalysisComRespDto!= null&& implementProgressValueManualFormAnalysisComRespDto.getProgressValueCalcFormula() == null &&implementActualValueManualFormAnalysisComRespDto!= null&& implementActualValueManualFormAnalysisComRespDto.getActualValueCalcFormula() == null &&reqDto!= null&&  reqDto.getIsSubjectiveScoring() !=null && reqDto.getIsSubjectiveScoring().equals("FALSE"))) {
        //if((D4-分析进度值是否人工汇报.进度值计算公式 值等于空  and D4-分析实际值是否人工汇报.实际值计算公式 值等于空  and D3-执行回写是否自动汇报(公共).是否开启主观评分 等于 否))  44873

boolean bOOLEAN_6 ;
    OmsTask omsTask_6=new OmsTask();
  omsTask_6.setIsAutoReport("TRUE");//sourceId:913567_1_44875
if(reqDto!=null){
      omsTask_6.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:913566_1_44875
    }

    /*3-7-01修改任务（修改为自动提交汇报）[2706]   */
    Assert.isNull(omsTask_6.getTaskId(),"D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为自动提交汇报）-任务ID不能为空",false);
Assert.isNull(omsTask_6.getIsAutoReport(),"D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为自动提交汇报）-是否自动汇报不能为空",false);
      bOOLEAN_6 = mOmsTaskService.updateTask(omsTask_6)/*vcase invoke 本地 method 方法调用;*/;



if((reqDto!= null&&  reqDto.getTargetValueType() !=null && reqDto.getTargetValueType().equals("SUBJECTIVE_QUALITATIVE")&&reqDto!= null&&  reqDto.getNoPracticalValueObjIsProgReport() !=null && reqDto.getNoPracticalValueObjIsProgReport().equals("TRUE")&&reqDto!= null&&  reqDto.getIsOkrPlanScene() !=null && reqDto.getIsOkrPlanScene().equals("NO_OKR_PLAN_SCENE")&&reqDto!= null&&  reqDto.getIndicatorKind() !=null && reqDto.getIndicatorKind().equals("OBJECTIVES")&&reqDto!= null&&  reqDto.getIsLastObjective() !=null && reqDto.getIsLastObjective().equals("TRUE"))) {
        //if((D3-执行回写是否自动汇报(公共).冗余指标业务类型 等于 主观定性 and D3-执行回写是否自动汇报(公共).无实际值指标是否开启进度汇报 等于 是 and D3-执行回写是否自动汇报(公共).冗余开启OKR场景 等于 无OKR场景 and D3-执行回写是否自动汇报(公共).OKR目标属性 等于 目标O and D3-执行回写是否自动汇报(公共).是否末级指标 等于 是))  49729

boolean bOOLEAN_7 ;
    OmsTask omsTask_7=new OmsTask();
  omsTask_7.setIsAutoReport("FALSE");//sourceId:1163528_1_49730
if(reqDto!=null){
      omsTask_7.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1163527_1_49730
    }

    /*3-7-01修改任务（修改为非自动提交汇报）[2706]   */
    Assert.isNull(omsTask_7.getTaskId(),"D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为非自动提交汇报）-任务ID不能为空",false);
Assert.isNull(omsTask_7.getIsAutoReport(),"D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为非自动提交汇报）-是否自动汇报不能为空",false);
      bOOLEAN_7 = mOmsTaskService.updateTask(omsTask_7)/*vcase invoke 本地 method 方法调用;*/;



      }
      }
      }
      }
//virtualUsage D3-执行自动汇报回写周期阶段资料（非人工填报内容）  60332
      ImplementAutoReportWBackCycleStageDataComRespDto implementAutoReportWBackCycleStageDataComRespDto = null;
    ImplementAutoReportWBackCycleStageDataComReqDto implementAutoReportWBackCycleStageDataComReqDto=new ImplementAutoReportWBackCycleStageDataComReqDto();
  if(reqDto!=null){
      implementAutoReportWBackCycleStageDataComReqDto.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1511072_1_60332
    }

    /*D3-执行自动汇报回写周期阶段资料（非人工填报内容）[8363]   */
    Assert.isNull(implementAutoReportWBackCycleStageDataComReqDto.getTaskId(),"D3-执行回写是否自动汇报(公共)-D3-执行自动汇报回写周期阶段资料（非人工填报内容）-任务ID不能为空",false);
      implementAutoReportWBackCycleStageDataComRespDto = taskService.implementAutoReportWBackCycleStageDataCom(implementAutoReportWBackCycleStageDataComReqDto)/*vcase invoke isSameApp*/;



ImplementWriteBackTaskAutoReportComRespDto retData = new ImplementWriteBackTaskAutoReportComRespDto();





return retData;
  }
/**
   * D3-执行标准数据计算周期模型分析(公共)[6546]
   * gen by moon at 6/25/2023, 8:07:52 AM
   */
  @Trace(operationName = "D3-执行标准数据计算周期模型分析(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCurrentCycleTypeAnalysisNoCalcComRespDto implementCurrentCycleTypeAnalysisNoCalcCom(ImplementCurrentCycleTypeAnalysisNoCalcComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_11 =null;
//virtualUsage 末级周期  40774
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq.setStandardDataCalcCycleModel("LAST_CYCLE");//sourceId:914848_1_40774

    /*末级周期[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getStandardDataCalcCycleModel(),"D3-执行标准数据计算周期模型分析(公共)-末级周期-标准数据计算周期模型不能为空",false);
      receptionServiceRes = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq);



//virtualUsage 中间周期  40775
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_1.setStandardDataCalcCycleModel("MID_OF_PROCESS_CYCLE");//sourceId:914849_1_40775

    /*中间周期[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getStandardDataCalcCycleModel(),"D3-执行标准数据计算周期模型分析(公共)-中间周期-标准数据计算周期模型不能为空",false);
      receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);



//virtualUsage 子周期  40776
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_2=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_2.setStandardDataCalcCycleModel("SUB_CYCLE");//sourceId:914851_1_40776

    /*子周期[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getStandardDataCalcCycleModel(),"D3-执行标准数据计算周期模型分析(公共)-子周期-标准数据计算周期模型不能为空",false);
      receptionServiceRes_4 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_2);



//virtualUsage 中期  40777
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_3=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_3.setStandardDataCalcCycleModel("MID_CYCLE");//sourceId:914852_1_40777

    /*中期[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getStandardDataCalcCycleModel(),"D3-执行标准数据计算周期模型分析(公共)-中期-标准数据计算周期模型不能为空",false);
      receptionServiceRes_6 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_3);



//virtualUsage 父周期  40779
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_8 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_4=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_4.setStandardDataCalcCycleModel("PARENT_CYCLE");//sourceId:914853_1_40779

    /*父周期[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getStandardDataCalcCycleModel(),"D3-执行标准数据计算周期模型分析(公共)-父周期-标准数据计算周期模型不能为空",false);
      receptionServiceRes_8 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_4);



if((reqDto!= null&&  reqDto.getIsFatherCycle() !=null && reqDto.getIsFatherCycle().equals("TRUE")&&reqDto!= null&&  reqDto.getIsSubCycle() !=null && reqDto.getIsSubCycle().equals("FALSE")&&reqDto!= null&&  reqDto.getIsMetaphase() !=null && reqDto.getIsMetaphase().equals("FALSE"))||(reqDto!= null&&  reqDto.getIsFatherCycle() !=null && reqDto.getIsFatherCycle().equals("TRUE")&&reqDto!= null&&  reqDto.getIsMetaphase() !=null && reqDto.getIsMetaphase().equals("TRUE")&&reqDto!= null&&  reqDto.getIsSubCycle() !=null && reqDto.getIsSubCycle().equals("FALSE"))||(reqDto!= null&&  reqDto.getIsFatherCycle() !=null && reqDto.getIsFatherCycle().equals("TRUE")&&reqDto!= null&&  reqDto.getIsSubCycle() !=null && reqDto.getIsSubCycle().equals("TRUE")&&reqDto!= null&&  reqDto.getIsMetaphase() !=null && reqDto.getIsMetaphase().equals("FALSE"))||(reqDto!= null&&  reqDto.getIsFatherCycle() !=null && reqDto.getIsFatherCycle().equals("TRUE")&&reqDto!= null&&  reqDto.getIsSubCycle() !=null && reqDto.getIsSubCycle().equals("TRUE")&&reqDto!= null&&  reqDto.getIsMetaphase() !=null && reqDto.getIsMetaphase().equals("TRUE"))) {
        //if((D3-执行标准数据计算周期模型分析(公共).是否父周期 等于 是 and D3-执行标准数据计算周期模型分析(公共).是否子周期 等于 否 and D3-执行标准数据计算周期模型分析(公共).是否中期 等于 否) or (D3-执行标准数据计算周期模型分析(公共).是否父周期 等于 是 and D3-执行标准数据计算周期模型分析(公共).是否中期 等于 是 and D3-执行标准数据计算周期模型分析(公共).是否子周期 等于 否) or (D3-执行标准数据计算周期模型分析(公共).是否父周期 等于 是 and D3-执行标准数据计算周期模型分析(公共).是否子周期 等于 是 and D3-执行标准数据计算周期模型分析(公共).是否中期 等于 否) or (D3-执行标准数据计算周期模型分析(公共).是否父周期 等于 是 and D3-执行标准数据计算周期模型分析(公共).是否子周期 等于 是 and D3-执行标准数据计算周期模型分析(公共).是否中期 等于 是))  44954

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1028739_1_45015
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1028736_1_45015
queryEvaObjTargetCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1028737_1_45015
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1028738_1_45015
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getCycleId(),"D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsEvaluationObjectTargetCycle != null )) {
        //if(3-3-09查周期是否目标周期.出参 值不等于空 )  45016

ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
    ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto=new ImplementStringEfficiencyCheckComReqDto();
  if(reqDto!=null){
      implementStringEfficiencyCheckComReqDto.setReferenceString(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:914253_1_46158
    }
if(omsEvaluationObjectTargetCycle!=null){
      implementStringEfficiencyCheckComReqDto.setComparisonString(omsEvaluationObjectTargetCycle.getCycleTypeCode());//SimpleFieldAssign//sourceId:914254_1_46158
    }

    /*D2-执行字符串对比(公共)[5774]   */
    Assert.isNull(implementStringEfficiencyCheckComReqDto.getReferenceString(),"D3-执行标准数据计算周期模型分析(公共)-D2-执行字符串对比(公共)-参照字符串不能为空",false);
      implementStringEfficiencyCheckComRespDto = fwCompInterfaceModeClient.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementStringEfficiencyCheckComRespDto!= null&&  implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("TRUE"))) {
        //if(D2-判断工作周期是否等于末级周期.字符串对比结果 等于 是)  46159

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_10 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_5=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_5.setStandardDataCalcCycleModel(receptionServiceRes.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914415_1_46160
    }

    /*约定出参：标准数据计算周期模型[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_5.getStandardDataCalcCycleModel(),"D3-执行标准数据计算周期模型分析(公共)-约定出参：标准数据计算周期模型-标准数据计算周期模型不能为空",false);
      receptionServiceRes_10 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_5);


      receptionServiceRes_11 = receptionServiceRes_10;
      }
else if((implementStringEfficiencyCheckComRespDto!= null&&  implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("FALSE"))){
       //elseif(D2-判断工作周期是否等于末级周期.字符串对比结果 等于 否)  46161

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_12 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_6=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_8!=null){
      receptionServiceReq_6.setStandardDataCalcCycleModel(receptionServiceRes_8.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914415_1_46162
    }

    /*约定出参：标准数据计算周期模型[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_6.getStandardDataCalcCycleModel(),"D3-执行标准数据计算周期模型分析(公共)-约定出参：标准数据计算周期模型-标准数据计算周期模型不能为空",false);
      receptionServiceRes_12 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_6);


      receptionServiceRes_11 = receptionServiceRes_12;
    }
      }
else if((omsEvaluationObjectTargetCycle == null )){
       //elseif(3-3-09查周期是否目标周期.出参 值等于空 )  45018

ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto_2 = null;
    ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto_1=new ImplementStringEfficiencyCheckComReqDto();
  if(reqDto!=null){
      implementStringEfficiencyCheckComReqDto_1.setReferenceString(reqDto.getCurrentCycleType());//SimpleFieldAssign//sourceId:914253_1_45022
implementStringEfficiencyCheckComReqDto_1.setComparisonString(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:914254_1_45022
    }

    /*D2-执行字符串对比(公共)[5774]   */
    Assert.isNull(implementStringEfficiencyCheckComReqDto_1.getReferenceString(),"D3-执行标准数据计算周期模型分析(公共)-D2-执行字符串对比(公共)-参照字符串不能为空",false);
      implementStringEfficiencyCheckComRespDto_2 = fwCompInterfaceModeClient.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



if((implementStringEfficiencyCheckComRespDto_2!= null&&  implementStringEfficiencyCheckComRespDto_2.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto_2.getStringEfficiencyCheckResult().equals("TRUE"))) {
        //if(D2-当前周期类型与末级周期类型对比.字符串对比结果 等于 是)  45023

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_13 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_7=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_7.setStandardDataCalcCycleModel(receptionServiceRes.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914415_1_45024
    }

    /*约定出参：标准数据计算周期模型[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_7.getStandardDataCalcCycleModel(),"D3-执行标准数据计算周期模型分析(公共)-约定出参：标准数据计算周期模型-标准数据计算周期模型不能为空",false);
      receptionServiceRes_13 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_7);


      receptionServiceRes_11 = receptionServiceRes_13;
    }
else if((implementStringEfficiencyCheckComRespDto_2!= null&&  implementStringEfficiencyCheckComRespDto_2.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto_2.getStringEfficiencyCheckResult().equals("FALSE"))){
       //elseif(D2-当前周期类型与末级周期类型对比.字符串对比结果 等于 否)  45025

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_14 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_8=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_8.setStandardDataCalcCycleModel(receptionServiceRes_2.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914415_1_45026
    }

    /*约定出参：标准数据计算周期模型[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_8.getStandardDataCalcCycleModel(),"D3-执行标准数据计算周期模型分析(公共)-约定出参：标准数据计算周期模型-标准数据计算周期模型不能为空",false);
      receptionServiceRes_14 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_8);


      receptionServiceRes_11 = receptionServiceRes_14;
    }
    }
      }
else if((reqDto!= null&&  reqDto.getIsMetaphase() !=null && reqDto.getIsMetaphase().equals("TRUE")&&reqDto!= null&&  reqDto.getIsFatherCycle() !=null && reqDto.getIsFatherCycle().equals("FALSE")&&reqDto!= null&&  reqDto.getIsSubCycle() !=null && reqDto.getIsSubCycle().equals("FALSE"))){
       //elseif((D3-执行标准数据计算周期模型分析(公共).是否中期 等于 是 and D3-执行标准数据计算周期模型分析(公共).是否父周期 等于 否 and D3-执行标准数据计算周期模型分析(公共).是否子周期 等于 否))  44956

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_1.setIsArchive("FALSE");//sourceId:1028739_1_45019
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_1.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1028736_1_45019
queryEvaObjTargetCycleDetailReq_1.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1028737_1_45019
queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1028738_1_45019
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTargetCycleId(),"D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getCycleId(),"D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(),"D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsArchive(),"D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



if((omsEvaluationObjectTargetCycle_2 != null )) {
        //if(3-3-09查周期是否目标中期.出参 值不等于空 )  45020

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_15 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_9=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_6!=null){
      receptionServiceReq_9.setStandardDataCalcCycleModel(receptionServiceRes_6.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914415_1_45021
    }

    /*约定出参：标准数据计算周期模型[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_9.getStandardDataCalcCycleModel(),"D3-执行标准数据计算周期模型分析(公共)-约定出参：标准数据计算周期模型-标准数据计算周期模型不能为空",false);
      receptionServiceRes_15 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_9);


      receptionServiceRes_11 = receptionServiceRes_15;
    }
      }
else if((reqDto!= null&&  reqDto.getIsSubCycle() !=null && reqDto.getIsSubCycle().equals("TRUE")&&reqDto!= null&&  reqDto.getIsFatherCycle() !=null && reqDto.getIsFatherCycle().equals("FALSE")&&reqDto!= null&&  reqDto.getIsMetaphase() !=null && reqDto.getIsMetaphase().equals("FALSE"))){
       //elseif((D3-执行标准数据计算周期模型分析(公共).是否子周期 等于 是 and D3-执行标准数据计算周期模型分析(公共).是否父周期 等于 否 and D3-执行标准数据计算周期模型分析(公共).是否中期 等于 否))  44958

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_3 = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_2=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_2.setIsArchive("FALSE");//sourceId:1028739_1_44960
  if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_2.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1028736_1_44960
queryEvaObjTargetCycleDetailReq_2.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1028737_1_44960
queryEvaObjTargetCycleDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1028738_1_44960
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjTargetCycleId(),"D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getCycleId(),"D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaluationTemplateId(),"D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getIsArchive(),"D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle_3 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;



if((omsEvaluationObjectTargetCycle_3 != null )) {
        //if(3-3-09查周期是否目标周期.出参 值不等于空 )  44961

ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto_3 = null;
    if(omsEvaluationObjectTargetCycle_3 !=null){
          ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto_2=new ImplementStringEfficiencyCheckComReqDto();
  if(omsEvaluationObjectTargetCycle_3!=null){
      implementStringEfficiencyCheckComReqDto_2.setReferenceString(omsEvaluationObjectTargetCycle_3.getCycleTypeCode());//SimpleFieldAssign//sourceId:914253_1_46163
    }
if(reqDto!=null){
      implementStringEfficiencyCheckComReqDto_2.setComparisonString(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:914254_1_46163
    }

    /*D2-执行字符串对比(公共)[5774]   */
    Assert.isNull(implementStringEfficiencyCheckComReqDto_2.getReferenceString(),"D3-执行标准数据计算周期模型分析(公共)-D2-执行字符串对比(公共)-参照字符串不能为空",false);
      implementStringEfficiencyCheckComRespDto_3 = fwCompInterfaceModeClient.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;



    }
if((implementStringEfficiencyCheckComRespDto_3!= null&&  implementStringEfficiencyCheckComRespDto_3.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto_3.getStringEfficiencyCheckResult().equals("FALSE"))) {
        //if(D2-子周期类型与末级周期类型对比.字符串对比结果 等于 否)  44969

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_16 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_10=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_4!=null){
      receptionServiceReq_10.setStandardDataCalcCycleModel(receptionServiceRes_4.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914415_1_44970
    }

    /*约定出参：标准数据计算周期模型[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_10.getStandardDataCalcCycleModel(),"D3-执行标准数据计算周期模型分析(公共)-约定出参：标准数据计算周期模型-标准数据计算周期模型不能为空",false);
      receptionServiceRes_16 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_10);


      receptionServiceRes_11 = receptionServiceRes_16;
    }
else if((implementStringEfficiencyCheckComRespDto_3!= null&&  implementStringEfficiencyCheckComRespDto_3.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto_3.getStringEfficiencyCheckResult().equals("TRUE"))){
       //elseif(D2-子周期类型与末级周期类型对比.字符串对比结果 等于 是)  44971

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_17 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_11=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_11.setStandardDataCalcCycleModel(receptionServiceRes.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914415_1_44972
    }

    /*约定出参：标准数据计算周期模型[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_11.getStandardDataCalcCycleModel(),"D3-执行标准数据计算周期模型分析(公共)-约定出参：标准数据计算周期模型-标准数据计算周期模型不能为空",false);
      receptionServiceRes_17 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_11);


      receptionServiceRes_11 = receptionServiceRes_17;
      }
      }
else if((omsEvaluationObjectTargetCycle_3 == null )){
       //elseif(3-3-09查周期是否目标周期.出参 值等于空 )  44963

ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto_4 = null;
    ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto_3=new ImplementStringEfficiencyCheckComReqDto();
  if(reqDto!=null){
      implementStringEfficiencyCheckComReqDto_3.setReferenceString(reqDto.getCurrentCycleType());//SimpleFieldAssign//sourceId:914253_1_44964
implementStringEfficiencyCheckComReqDto_3.setComparisonString(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:914254_1_44964
    }

    /*D2-执行字符串对比(公共)[5774]   */
    Assert.isNull(implementStringEfficiencyCheckComReqDto_3.getReferenceString(),"D3-执行标准数据计算周期模型分析(公共)-D2-执行字符串对比(公共)-参照字符串不能为空",false);
      implementStringEfficiencyCheckComRespDto_4 = fwCompInterfaceModeClient.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;



if((implementStringEfficiencyCheckComRespDto_4!= null&&  implementStringEfficiencyCheckComRespDto_4.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto_4.getStringEfficiencyCheckResult().equals("TRUE"))) {
        //if(D2-当前周期类型与末级周期类型对比.字符串对比结果 等于 是)  44965

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_18 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_12=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_12.setStandardDataCalcCycleModel(receptionServiceRes.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914415_1_44966
    }

    /*约定出参：标准数据计算周期模型[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_12.getStandardDataCalcCycleModel(),"D3-执行标准数据计算周期模型分析(公共)-约定出参：标准数据计算周期模型-标准数据计算周期模型不能为空",false);
      receptionServiceRes_18 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_12);


      receptionServiceRes_11 = receptionServiceRes_18;
    }
else if((implementStringEfficiencyCheckComRespDto_4!= null&&  implementStringEfficiencyCheckComRespDto_4.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto_4.getStringEfficiencyCheckResult().equals("FALSE"))){
       //elseif(D2-当前周期类型与末级周期类型对比.字符串对比结果 等于 否)  44967

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_19 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_13=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_13.setStandardDataCalcCycleModel(receptionServiceRes_2.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914415_1_44968
    }

    /*约定出参：标准数据计算周期模型[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_13.getStandardDataCalcCycleModel(),"D3-执行标准数据计算周期模型分析(公共)-约定出参：标准数据计算周期模型-标准数据计算周期模型不能为空",false);
      receptionServiceRes_19 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_13);


      receptionServiceRes_11 = receptionServiceRes_19;
    }
    }
    }
ImplementCurrentCycleTypeAnalysisNoCalcComRespDto retData = new ImplementCurrentCycleTypeAnalysisNoCalcComRespDto();
  if(receptionServiceRes_11!=null){
      retData.setStandardDataCalcCycleModel(receptionServiceRes_11.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914879_1
    }




return retData;
  }


/**
   * D3-执行重新计算标准数据(公共)[6521]
   * gen by moon at 5/10/2023, 1:31:59 AM
   */
  @Trace(operationName = "D3-执行重新计算标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementRecalcStandardDataComRespDto implementRecalcStandardDataCom(ImplementRecalcStandardDataComReqDto reqDto){

//
//      //virtualUsage D4-1查询标准数据列表(公共)  40510
//      QueryStandardDataListComRespDto queryStandardDataListComRespDto = null;
//    QueryStandardDataListComReqDto queryStandardDataListComReqDto=new QueryStandardDataListComReqDto();
//  queryStandardDataListComReqDto.setIsNewData("TRUE");//sourceId:904101_1_40510
//queryStandardDataListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:904104_1_40510
//if(reqDto!=null){
//      queryStandardDataListComReqDto.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:904103_1_40510
//queryStandardDataListComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:904105_1_40510
//    }
//
//    /*D4-1查询标准数据列表(公共)[4696]   */
//    Assert.isNull(queryStandardDataListComReqDto.getEntityId(),"D3-执行重新计算标准数据(公共)-D4-1查询标准数据列表(公共)-归属内容表主键ID不能为空",false);
//Assert.isNull(queryStandardDataListComReqDto.getIsNewData(),"D3-执行重新计算标准数据(公共)-D4-1查询标准数据列表(公共)-是否归属周期最新数据不能为空",false);
//Assert.isNull(queryStandardDataListComReqDto.getSubjectLifeCycle(),"D3-执行重新计算标准数据(公共)-D4-1查询标准数据列表(公共)-主体生命周期不能为空",false);
//Assert.isNull(queryStandardDataListComReqDto.getThemeContentId(),"D3-执行重新计算标准数据(公共)-D4-1查询标准数据列表(公共)-主题内容ID不能为空",false);
//      queryStandardDataListComRespDto = fwCalcStandardDataClient.queryStandardDataListCom(queryStandardDataListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
//
//
//
//if((queryStandardDataListComRespDto!= null&&  queryStandardDataListComRespDto.getStandardDataList() !=null && queryStandardDataListComRespDto.getStandardDataList().size()>0)) {
//        //if(D4-1查询标准数据列表(公共).标准数据列表数据集条数 大于 0)  40512
//
////ModelCode: circulationCollections
//        for (StandardDataDto circulationCollectionsRes: queryStandardDataListComRespDto.getStandardDataList()){
//
//OmsExecuteCycleStage omsExecuteCycleStage = null;
//    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();
//  queryExecuteCycleStageDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:910411_1_40678
//if(circulationCollectionsRes!=null){
////      queryExecuteCycleStageDetailReq.setCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:910409_1_40678
//    }
//if(reqDto!=null){
//      queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:910410_1_40678
//    }
//
//    /*3-3-07查询执行周期阶段详情[2429]   */
//    Assert.isNull(queryExecuteCycleStageDetailReq.getCycleId(),"D3-执行重新计算标准数据(公共)-3-3-07查询执行周期阶段详情-周期ID不能为空",false);
//Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(),"D3-执行重新计算标准数据(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
//Assert.isNull(queryExecuteCycleStageDetailReq.getSubjectLifeCycle(),"D3-执行重新计算标准数据(公共)-3-3-07查询执行周期阶段详情-主体生命周期不能为空",false);
//      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;
//
//
//
//QueryPrepareForCalcContentDetailComRespDto queryPrepareForCalcContentDetailComRespDto = null;
//    if(omsExecuteCycleStage !=null){
//          QueryPrepareForCalcContentDetailComReqDto queryPrepareForCalcContentDetailComReqDto=new QueryPrepareForCalcContentDetailComReqDto();
//  if(circulationCollectionsRes!=null){
////      queryPrepareForCalcContentDetailComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:910263_1_40675
//    }
//if(omsExecuteCycleStage!=null){
//      queryPrepareForCalcContentDetailComReqDto.setExecuteCycleStageId(omsExecuteCycleStage.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:910264_1_40675
//    }
//if(reqDto!=null){
//      queryPrepareForCalcContentDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:910265_1_40675
//    }
//
//    /*D4-查询计算准备的内容信息详情(公共)[5993]   */
//    Assert.isNull(queryPrepareForCalcContentDetailComReqDto.getEvaObjTargetCycleId(),"D3-执行重新计算标准数据(公共)-D4-查询计算准备的内容信息详情(公共)-被评对象目标周期ID不能为空",false);
//Assert.isNull(queryPrepareForCalcContentDetailComReqDto.getExecuteCycleStageId(),"D3-执行重新计算标准数据(公共)-D4-查询计算准备的内容信息详情(公共)-执行周期阶段ID不能为空",false);
//Assert.isNull(queryPrepareForCalcContentDetailComReqDto.getEvaluationTemplateId(),"D3-执行重新计算标准数据(公共)-D4-查询计算准备的内容信息详情(公共)-冗余评价模板ID不能为空",false);
//      queryPrepareForCalcContentDetailComRespDto = fwCalcStandardDataClient.queryPrepareForCalcContentDetailCom(queryPrepareForCalcContentDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
//
//
//
//           }
//if((circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("ACTUAL_VALUE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("CHANGE_FROM_LAST_TARGET")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("FROM_LAST_TARGET_LIFT_RATIO")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("COUNT_ACTUAL_VALUE"))) {
//        //if((M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 实际值 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 较上次目标变化值 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 较上次目标增降幅 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 计算实际值))  40669
//
//ImplementActualValueCalcFormulaAnalysisComRespDto implementActualValueCalcFormulaAnalysisComRespDto = null;
//    if(queryPrepareForCalcContentDetailComRespDto !=null){
//          ImplementActualValueCalcFormulaAnalysisComReqDto implementActualValueCalcFormulaAnalysisComReqDto=new ImplementActualValueCalcFormulaAnalysisComReqDto();
//  if(reqDto!=null){
//      implementActualValueCalcFormulaAnalysisComReqDto.setSchemeDataPara(reqDto.getSchemeDataPara());//SimpleFieldAssign//sourceId:910192_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setReportType(reqDto.getReportType());//SimpleFieldAssign//sourceId:910193_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setIsOkrPlanScene(reqDto.getIsOkrPlanScene());//SimpleFieldAssign//sourceId:910202_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setIsOpenSubReportLimit(reqDto.getIsOpenSubReportLimit());//SimpleFieldAssign//sourceId:910206_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setLastCycleType(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:910214_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setDecimalPointRules(reqDto.getActualValueDecimalPoint());//SimpleFieldAssign//sourceId:910209_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:910210_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:910201_1_40670
//    }
//if(circulationCollectionsRes!=null){
//      implementActualValueCalcFormulaAnalysisComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:910200_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:910205_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setUpdateCycleId(circulationCollectionsRes.getUpdateCycleId());//SimpleFieldAssign//sourceId:910213_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setParentSubMidCycleType(circulationCollectionsRes.getParentSubMidCycleType()!=null?String.valueOf(circulationCollectionsRes.getParentSubMidCycleType()):"");//SimpleFieldAssign//sourceId:910207_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setUpdateBatch(circulationCollectionsRes.getUpdateBatch());//SimpleFieldAssign//sourceId:910211_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setWorkCycleUpdateSlice(circulationCollectionsRes.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:910212_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setStandardDataCalcCycleModel(circulationCollectionsRes.getStandardDataCalcCycleModel()!=null?String.valueOf(circulationCollectionsRes.getStandardDataCalcCycleModel()):"");//SimpleFieldAssign//sourceId:910199_1_40670
//    }
//if(queryPrepareForCalcContentDetailComRespDto!=null){
//      implementActualValueCalcFormulaAnalysisComReqDto.setEvaObjTypeCode(queryPrepareForCalcContentDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:910198_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setTargetCycleContentTypeCode(queryPrepareForCalcContentDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:910197_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setTargetValueType(queryPrepareForCalcContentDetailComRespDto.getTargetValueType());//SimpleFieldAssign//sourceId:910194_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setIndicatorKind(queryPrepareForCalcContentDetailComRespDto.getIndicatorKind());//SimpleFieldAssign//sourceId:910204_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setIsLastObjective(queryPrepareForCalcContentDetailComRespDto.getIsLastObjective());//SimpleFieldAssign//sourceId:910195_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setCalculateDataSource(queryPrepareForCalcContentDetailComRespDto.getCalculateDataSource());//SimpleFieldAssign//sourceId:910196_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setQuantityObjectiveNoValue(queryPrepareForCalcContentDetailComRespDto.getQuantityObjectiveNoValue());//SimpleFieldAssign//sourceId:910203_1_40670
//    }
//
//    /*D4-执行实际值公式分析(公共)[6389]   */
//    Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getSchemeDataPara(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-评价模板数据参数不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getReportType(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-汇报类型不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getIsOkrPlanScene(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-冗余开启OKR场景不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getIsOpenSubReportLimit(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-是否开启下级汇报限制不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getLastCycleType(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-末级周期类型不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getDecimalPointRules(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-小数点规则不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getDecimalDigitsLastRules(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-小数最后一位规则不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getEvaObjTargetCycleId(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-被评对象目标周期ID不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getEvaObjTypeCode(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-被评对象类型编码不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getTargetCycleContentTypeCode(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-关联目标内容类型编码不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getEvaluationTemplateId(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-冗余评价模板ID不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getCycleId(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-周期ID不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getUpdateCycleId(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-更新周期ID不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getParentSubMidCycleType(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-父子中周期类型不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getUpdateBatch(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-数据更新批次（时间点）不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getWorkCycleUpdateSlice(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-工作周期更新切片不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getStandardDataCalcCycleModel(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-标准数据计算周期模型不能为空",false);
//      implementActualValueCalcFormulaAnalysisComRespDto = fwCalcGridCalculateClient.implementActualValueCalcFormulaAnalysisCom(implementActualValueCalcFormulaAnalysisComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
//
//
//
//           }
//      }
//else if((circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("PROGRESS_VALUE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("FROM_LAST_PROGRESS_VALUE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("PROGRESS_FROM_LAST_RATIO")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("COUNT_PROGRESS_VALUE"))){
//       //elseif((M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 进度值 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 进度较上次变化值 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 进度较上次增降幅 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 计算进度值))  40671
//
//ImplementProgressValueCalcFormulaAnalysisComRespDto implementProgressValueCalcFormulaAnalysisComRespDto = null;
//    if(queryPrepareForCalcContentDetailComRespDto !=null){
//          ImplementProgressValueCalcFormulaAnalysisComReqDto implementProgressValueCalcFormulaAnalysisComReqDto=new ImplementProgressValueCalcFormulaAnalysisComReqDto();
//  if(reqDto!=null){
//      implementProgressValueCalcFormulaAnalysisComReqDto.setSchemeDataPara(reqDto.getSchemeDataPara());//SimpleFieldAssign//sourceId:910170_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setReportType(reqDto.getReportType());//SimpleFieldAssign//sourceId:910172_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setIsOpenSubReportLimit(reqDto.getIsOpenSubReportLimit());//SimpleFieldAssign//sourceId:910180_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setIsOkrPlanScene(reqDto.getIsOkrPlanScene());//SimpleFieldAssign//sourceId:910175_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setKrWeight(reqDto.getKrWeight());//SimpleFieldAssign//sourceId:910189_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setOWeight(reqDto.getOWeight());//SimpleFieldAssign//sourceId:910190_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setDecimalPointRules(reqDto.getProgressDecimalPoint());//SimpleFieldAssign//sourceId:910186_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:910187_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:910174_1_40672
//    }
//if(circulationCollectionsRes!=null){
//      implementProgressValueCalcFormulaAnalysisComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:910176_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:910177_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setUpdateCycleId(circulationCollectionsRes.getUpdateCycleId());//SimpleFieldAssign//sourceId:910191_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setParentSubMidCycleType(circulationCollectionsRes.getParentSubMidCycleType()!=null?String.valueOf(circulationCollectionsRes.getParentSubMidCycleType()):"");//SimpleFieldAssign//sourceId:910181_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setUpdateBatch(circulationCollectionsRes.getUpdateBatch());//SimpleFieldAssign//sourceId:910185_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setWorkCycleUpdateSlice(circulationCollectionsRes.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:910188_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setStandardDataCalcCycleModel(circulationCollectionsRes.getStandardDataCalcCycleModel()!=null?String.valueOf(circulationCollectionsRes.getStandardDataCalcCycleModel()):"");//SimpleFieldAssign//sourceId:910178_1_40672
//    }
//if(queryPrepareForCalcContentDetailComRespDto!=null){
//      implementProgressValueCalcFormulaAnalysisComReqDto.setEvaObjTypeCode(queryPrepareForCalcContentDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:910179_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setTargetCycleContentTypeCode(queryPrepareForCalcContentDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:910173_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setIsLastObjective(queryPrepareForCalcContentDetailComRespDto.getIsLastObjective());//SimpleFieldAssign//sourceId:910171_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setTargetValueType(queryPrepareForCalcContentDetailComRespDto.getTargetValueType());//SimpleFieldAssign//sourceId:910182_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setIndicatorKind(queryPrepareForCalcContentDetailComRespDto.getIndicatorKind());//SimpleFieldAssign//sourceId:910183_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setCalculateDataSource(queryPrepareForCalcContentDetailComRespDto.getCalculateDataSource());//SimpleFieldAssign//sourceId:910184_1_40672
//    }
//
//    /*D4-执行进度值公式分析(公共)[6388]   */
//    Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getSchemeDataPara(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-评价模板数据参数不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getReportType(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-汇报类型不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getIsOpenSubReportLimit(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-是否开启下级汇报限制不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getIsOkrPlanScene(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-冗余开启OKR场景不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getKrWeight(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-下级KR权重不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getOWeight(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-下级O权重不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getDecimalPointRules(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-小数点规则不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getDecimalDigitsLastRules(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-小数最后一位规则不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getEvaObjTargetCycleId(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-被评对象目标周期ID不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getEvaObjTypeCode(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-被评对象类型编码不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getTargetCycleContentTypeCode(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-关联目标内容类型编码不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getCycleId(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-周期ID不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getUpdateCycleId(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-更新周期ID不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getParentSubMidCycleType(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-父子中周期类型不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getUpdateBatch(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-数据更新批次（时间点）不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getWorkCycleUpdateSlice(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-工作周期更新切片不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getStandardDataCalcCycleModel(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-标准数据计算周期模型不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getEvaluationTemplateId(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-冗余评价模板ID不能为空",false);
//      implementProgressValueCalcFormulaAnalysisComRespDto = fwCalcGridCalculateClient.implementProgressValueCalcFormulaAnalysisCom(implementProgressValueCalcFormulaAnalysisComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
//
//
//
//           }
//    }
//else if((circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("REPORT_SCORE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("FROM_LAST_REPORT_SCORE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("FROM_LAST_RATIO_REPORT_SCORE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("ACTUAL_SCORE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("FROM_LAST_ACTUAL_SCORE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("FROM_LAST_RATIO_ACTUAL_SCORE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("REACH")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("FROM_LAST_REACH")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("ACTUAL_FROM_LAST_TIME_RATIO"))){
//       //elseif((M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 汇报得分 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 汇报得分较上次变化值 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 汇报得分较上次增降幅 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 实际得分 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 实际得分较上次变化值 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 实际得分较上次增降幅 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 达成度 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 达成度较上次变化值 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 达成度较上次增降福))  40673
//
//ImplementFiveCycleTypeScoreComRespDto implementFiveCycleTypeScoreComRespDto = null;
//    if(queryPrepareForCalcContentDetailComRespDto !=null){
//          ImplementFiveCycleTypeScoreComReqDto implementFiveCycleTypeScoreComReqDto=new ImplementFiveCycleTypeScoreComReqDto();
//  if(reqDto!=null){
//      implementFiveCycleTypeScoreComReqDto.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:910228_1_40674
//implementFiveCycleTypeScoreComReqDto.setSchemeDataPara(reqDto.getSchemeDataPara());//SimpleFieldAssign//sourceId:910216_1_40674
//implementFiveCycleTypeScoreComReqDto.setActualScoreIsOpenLocalLevelScore(reqDto.getActualScoreIsOpenLocalLevelScore());//SimpleFieldAssign//sourceId:910217_1_40674
//implementFiveCycleTypeScoreComReqDto.setIsOkrPlanScene(reqDto.getIsOkrPlanScene());//SimpleFieldAssign//sourceId:910224_1_40674
//implementFiveCycleTypeScoreComReqDto.setOpenOrCloseMidProcess(reqDto.getOpenOrCloseMidProcess());//SimpleFieldAssign//sourceId:910249_1_40674
//implementFiveCycleTypeScoreComReqDto.setLastCycleType(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:910248_1_40674
//implementFiveCycleTypeScoreComReqDto.setCycleTypeCode(reqDto.getMidOfProcessCycleType());//SimpleFieldAssign//sourceId:910250_1_40674
//implementFiveCycleTypeScoreComReqDto.setDecimalPointRules(reqDto.getScoreDecimalPoint());//SimpleFieldAssign//sourceId:910229_1_40674
//implementFiveCycleTypeScoreComReqDto.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:910230_1_40674
//implementFiveCycleTypeScoreComReqDto.setSubjectiveScoreWeight(reqDto.getSubjectiveScoreWeight());//SimpleFieldAssign//sourceId:910232_1_40674
//implementFiveCycleTypeScoreComReqDto.setObjectiveScoreWeight(reqDto.getObjectiveScoreWeight());//SimpleFieldAssign//sourceId:910233_1_40674
//implementFiveCycleTypeScoreComReqDto.setProcessMidWeight(reqDto.getProcessMidWeight());//SimpleFieldAssign//sourceId:910234_1_40674
//implementFiveCycleTypeScoreComReqDto.setMidReportWeight(reqDto.getMidReportWeight());//SimpleFieldAssign//sourceId:910240_1_40674
//implementFiveCycleTypeScoreComReqDto.setReportAvgScoreWeight(reqDto.getReportAvgScoreWeight());//SimpleFieldAssign//sourceId:910235_1_40674
//implementFiveCycleTypeScoreComReqDto.setProcessReportScoreWeight(reqDto.getProcessReportScoreWeight());//SimpleFieldAssign//sourceId:910236_1_40674
//implementFiveCycleTypeScoreComReqDto.setSubjectiveAndObjectiveScoreWeight(reqDto.getSubjectiveAndObjectiveScoreWeight());//SimpleFieldAssign//sourceId:910237_1_40674
//implementFiveCycleTypeScoreComReqDto.setLocalLevelScoreWeight(reqDto.getLocalLevelScoreWeight());//SimpleFieldAssign//sourceId:910238_1_40674
//implementFiveCycleTypeScoreComReqDto.setLowerLevelScoreWeight(reqDto.getLowerLevelScoreWeight());//SimpleFieldAssign//sourceId:910239_1_40674
//implementFiveCycleTypeScoreComReqDto.setKrWeight(reqDto.getKrWeight());//SimpleFieldAssign//sourceId:910231_1_40674
//implementFiveCycleTypeScoreComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:910222_1_40674
//    }
//if(circulationCollectionsRes!=null){
//      implementFiveCycleTypeScoreComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:910218_1_40674
//implementFiveCycleTypeScoreComReqDto.setCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:910221_1_40674
//implementFiveCycleTypeScoreComReqDto.setUpdateCycleId(circulationCollectionsRes.getUpdateCycleId());//SimpleFieldAssign//sourceId:910245_1_40674
//implementFiveCycleTypeScoreComReqDto.setParentSubMidCycleType(circulationCollectionsRes.getParentSubMidCycleType()!=null?String.valueOf(circulationCollectionsRes.getParentSubMidCycleType()):"");//SimpleFieldAssign//sourceId:910243_1_40674
//implementFiveCycleTypeScoreComReqDto.setUpdateBatch(circulationCollectionsRes.getUpdateBatch());//SimpleFieldAssign//sourceId:910242_1_40674
//implementFiveCycleTypeScoreComReqDto.setStandardDataCalcCycleModel(circulationCollectionsRes.getStandardDataCalcCycleModel()!=null?String.valueOf(circulationCollectionsRes.getStandardDataCalcCycleModel()):"");//SimpleFieldAssign//sourceId:910215_1_40674
//    }
//if(queryPrepareForCalcContentDetailComRespDto!=null){
//      implementFiveCycleTypeScoreComReqDto.setEvaObjTypeCode(queryPrepareForCalcContentDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:910219_1_40674
//implementFiveCycleTypeScoreComReqDto.setComFloatField2(queryPrepareForCalcContentDetailComRespDto.getWeightValue());//SimpleFieldAssign//sourceId:910247_1_40674
//implementFiveCycleTypeScoreComReqDto.setWeightScore(queryPrepareForCalcContentDetailComRespDto.getWeightScore());//SimpleFieldAssign//sourceId:910241_1_40674
//implementFiveCycleTypeScoreComReqDto.setIsSubjectiveScoring(queryPrepareForCalcContentDetailComRespDto.getIsSubjectiveScoring());//SimpleFieldAssign//sourceId:910225_1_40674
//implementFiveCycleTypeScoreComReqDto.setIsObjectiveQuantization(queryPrepareForCalcContentDetailComRespDto.getIsObjectiveQuantization());//SimpleFieldAssign//sourceId:910226_1_40674
//implementFiveCycleTypeScoreComReqDto.setTargetCycleContentTypeCode(queryPrepareForCalcContentDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:910220_1_40674
//implementFiveCycleTypeScoreComReqDto.setReportObjectSetCode(queryPrepareForCalcContentDetailComRespDto.getReportObjectSetCode());//SimpleFieldAssign//sourceId:910244_1_40674
//implementFiveCycleTypeScoreComReqDto.setIsLastObjective(queryPrepareForCalcContentDetailComRespDto.getIsLastObjective());//SimpleFieldAssign//sourceId:910227_1_40674
//implementFiveCycleTypeScoreComReqDto.setIndicatorKind(queryPrepareForCalcContentDetailComRespDto.getIndicatorKind());//SimpleFieldAssign//sourceId:910223_1_40674
//implementFiveCycleTypeScoreComReqDto.setTargetValueType(queryPrepareForCalcContentDetailComRespDto.getTargetValueType());//SimpleFieldAssign//sourceId:910252_1_40674
//implementFiveCycleTypeScoreComReqDto.setQuantityObjectiveNoValue(queryPrepareForCalcContentDetailComRespDto.getQuantityObjectiveNoValue());//SimpleFieldAssign//sourceId:910253_1_40674
//implementFiveCycleTypeScoreComReqDto.setCycleStartTime(queryPrepareForCalcContentDetailComRespDto.getSubCycleStarttime());//SimpleFieldAssign//sourceId:910251_1_40674
//    }
//
//    /*D4-执行五类周期得分分析(公共)[6482]   */
//    Assert.isNull(implementFiveCycleTypeScoreComReqDto.getCustomField(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-得分公式不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getSchemeDataPara(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-评价模板数据参数不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getActualScoreIsOpenLocalLevelScore(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-实际得分是否开启本级得分不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getIsOkrPlanScene(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-冗余开启OKR场景不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getOpenOrCloseMidProcess(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-开启或不开启过程中期不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getLastCycleType(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-末级周期类型不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getCycleTypeCode(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-过程中期周期类型不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getDecimalPointRules(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-小数点规则不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getDecimalDigitsLastRules(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-小数最后一位规则不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getSubjectiveScoreWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-主观得分权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getObjectiveScoreWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-客观得分权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getProcessMidWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-过程中期权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getMidReportWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-中期汇报得分权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getReportAvgScoreWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-汇报平均分权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getProcessReportScoreWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-过程汇报得分权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getSubjectiveAndObjectiveScoreWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-主客观得分权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getLocalLevelScoreWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-本级得分权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getLowerLevelScoreWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-下级得分权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getKrWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-下级KR权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getEvaObjTargetCycleId(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-被评对象目标周期ID不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getEvaObjTypeCode(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-被评对象类型编码不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getComFloatField2(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-目标树叶子节点权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getWeightScore(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-权重分值不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getIsSubjectiveScoring(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-是否开启主观评分不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getIsObjectiveQuantization(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-是否开启量化客观评分不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getTargetCycleContentTypeCode(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-关联目标内容类型编码不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getEvaluationTemplateId(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-冗余评价模板ID不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getCycleId(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-周期ID不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getUpdateCycleId(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-更新周期ID不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getCycleStartTime(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-子周期周期开始时间不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getParentSubMidCycleType(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-父子中周期类型不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getUpdateBatch(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-数据更新批次（时间点）不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getStandardDataCalcCycleModel(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-标准数据计算周期模型不能为空",false);
//      implementFiveCycleTypeScoreComRespDto = fwCalcGridCalculateClient.implementFiveCycleTypeScoreCom(implementFiveCycleTypeScoreComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
//
//
//
//           }
//    }
////ModelCode: circulationEnd
//        }
//
//      }
ImplementRecalcStandardDataComRespDto retData = new ImplementRecalcStandardDataComRespDto();





return retData;
  }

/**
   * D3-计算因子接收字段(公共)[6532]
   * gen by moon at 7/5/2023, 1:26:37 AM
   */
  @Trace(operationName = "D3-计算因子接收字段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCalcReceivingFieldComRespDto implementCalcReceivingFieldCom(ImplementCalcReceivingFieldComReqDto reqDto){


      //步骤0: M3-计算接收上文字段（特殊方法） - calculateAcceptAboveFields
     //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:907885_1
receptionServiceReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:910927_1
receptionServiceReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1006840_1
receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1006841_1
receptionServiceReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:907890_1
receptionServiceReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:907891_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:907893_1
receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:907894_1
receptionServiceReq.setLastCycleType(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:907895_1
receptionServiceReq.setFatherCycleType(reqDto.getFatherCycleType());//SimpleFieldAssign//sourceId:907896_1
receptionServiceReq.setMidCycleType(reqDto.getMidCycleType());//SimpleFieldAssign//sourceId:907897_1
receptionServiceReq.setStandardDataCalcCycleModel(reqDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1009244_1
receptionServiceReq.setSubcycleType(reqDto.getSubcycleType());//SimpleFieldAssign//sourceId:907898_1
receptionServiceReq.setCurrentCycleType(reqDto.getCurrentCycleType());//SimpleFieldAssign//sourceId:907901_1
receptionServiceReq.setIsFatherCycle(reqDto.getIsFatherCycle());//SimpleFieldAssign//sourceId:1009248_1
receptionServiceReq.setExecuteCycleStageList(reqDto.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:908204_1
receptionServiceReq.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:907904_1
receptionServiceReq.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1009249_1
receptionServiceReq.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1009250_1
receptionServiceReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:907908_1
receptionServiceReq.setHaveProcessCycle(reqDto.getHaveProcessCycle());//SimpleFieldAssign//sourceId:907909_1
receptionServiceReq.setCycleMode(reqDto.getCycleMode());//SimpleFieldAssign//sourceId:907910_1
receptionServiceReq.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:907914_1
receptionServiceReq.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:907915_1
receptionServiceReq.setSchemeDataPara(reqDto.getSchemeDataPara());//SimpleFieldAssign//sourceId:907917_1
receptionServiceReq.setReportType(reqDto.getReportType());//SimpleFieldAssign//sourceId:907918_1
receptionServiceReq.setActualScoreIsOpenLocalLevelScore(reqDto.getActualScoreIsOpenLocalLevelScore());//SimpleFieldAssign//sourceId:907919_1
receptionServiceReq.setIsOpenSubReportLimit(reqDto.getIsOpenSubReportLimit());//SimpleFieldAssign//sourceId:907920_1
receptionServiceReq.setIsOkrPlanScene(reqDto.getIsOkrPlanScene());//SimpleFieldAssign//sourceId:907921_1
receptionServiceReq.setOpenOrCloseMidProcess(reqDto.getOpenOrCloseMidProcess());//SimpleFieldAssign//sourceId:907924_1
receptionServiceReq.setOpenOrCloseMidCycle(reqDto.getOpenOrCloseMidCycle());//SimpleFieldAssign//sourceId:907925_1
receptionServiceReq.setActualValueDecimalPoint(reqDto.getActualValueDecimalPoint());//SimpleFieldAssign//sourceId:907926_1
receptionServiceReq.setScoreDecimalPoint(reqDto.getScoreDecimalPoint());//SimpleFieldAssign//sourceId:907928_1
receptionServiceReq.setProgressDecimalPoint(reqDto.getProgressDecimalPoint());//SimpleFieldAssign//sourceId:907930_1
receptionServiceReq.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:907931_1
receptionServiceReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:907932_1
receptionServiceReq.setSubjectiveScoreWeight(reqDto.getSubjectiveScoreWeight());//SimpleFieldAssign//sourceId:907933_1
receptionServiceReq.setObjectiveScoreWeight(reqDto.getObjectiveScoreWeight());//SimpleFieldAssign//sourceId:907934_1
receptionServiceReq.setProcessReportScoreProMidWeight(reqDto.getProcessReportScoreProMidWeight());//SimpleFieldAssign//sourceId:907935_1
receptionServiceReq.setProcessReportScoreAvgWeight(reqDto.getProcessReportScoreAvgWeight());//SimpleFieldAssign//sourceId:907936_1
receptionServiceReq.setProcessReportScoreKrWeight(reqDto.getProcessReportScoreKrWeight());//SimpleFieldAssign//sourceId:907937_1
receptionServiceReq.setReportScoreProcessWeight(reqDto.getReportScoreProcessWeight());//SimpleFieldAssign//sourceId:907938_1
receptionServiceReq.setReportScoreSubAndObjWeight(reqDto.getReportScoreSubAndObjWeight());//SimpleFieldAssign//sourceId:907939_1
receptionServiceReq.setActualScoreLocalLevelWeight(reqDto.getActualScoreLocalLevelWeight());//SimpleFieldAssign//sourceId:907940_1
receptionServiceReq.setActualScoreLowerLevelWeight(reqDto.getActualScoreLowerLevelWeight());//SimpleFieldAssign//sourceId:907941_1
receptionServiceReq.setProcessReportScoreMidWeight(reqDto.getProcessReportScoreMidWeight());//SimpleFieldAssign//sourceId:907942_1
receptionServiceReq.setOWeight(reqDto.getOWeight());//SimpleFieldAssign//sourceId:907943_1
receptionServiceReq.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1009307_1
receptionServiceReq.setMidOfProcessCycleType(reqDto.getMidOfProcessCycleType());//SimpleFieldAssign//sourceId:907944_1
receptionServiceReq.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:908131_1
receptionServiceReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1009260_1
receptionServiceReq.setSubObjectWeight(reqDto.getSubObjectWeight());//SimpleFieldAssign//sourceId:960578_1
receptionServiceReq.setSubjectiveRatingTotalValue(reqDto.getSubjectiveRatingTotalValue());//SimpleFieldAssign//sourceId:976943_1
receptionServiceReq.setCountProObWeight(reqDto.getCountProObWeight());//SimpleFieldAssign//sourceId:988140_1
receptionServiceReq.setCountProKrWeight(reqDto.getCountProKrWeight());//SimpleFieldAssign//sourceId:988141_1
receptionServiceReq.setExecuteProgressValue(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:1077877_1
receptionServiceReq.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1077878_1
receptionServiceReq.setSubCycleIsLastCycle(reqDto.getSubCycleIsLastCycle());//SimpleFieldAssign//sourceId:1054710_1
receptionServiceReq.setSubjectiveRatingTotalValueUnit(reqDto.getSubjectiveRatingTotalValueUnit());//SimpleFieldAssign//sourceId:1058239_1
    }

    /*M3-计算接收上文字段（特殊方法）[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq);




ImplementCalcReceivingFieldComRespDto retData = new ImplementCalcReceivingFieldComRespDto();





return retData;
  }





/**
   * D3-审核汇报任务资料和标准数据(公共)[6376]
   * gen by moon at 6/8/2024, 8:39:05 PM
   */
  @Trace(operationName = "D3-审核汇报任务资料和标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ApproveSucceedReportTaskComRespDto approveSucceedReportTaskCom(ApproveSucceedReportTaskComReqDto reqDto){


//virtualUsage D3-3更新周期阶段资料(公共)  50794
RefreshCycleStageDataComRespDto refreshCycleStageDataComRespDto = null;
    RefreshCycleStageDataComReqDto refreshCycleStageDataComReqDto=new RefreshCycleStageDataComReqDto();
  if(reqDto!=null){
      refreshCycleStageDataComReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:868149_1_50794
refreshCycleStageDataComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:868152_1_50794
refreshCycleStageDataComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:868151_1_50794
    }

    /*D3-3更新周期阶段资料(公共)[3154]   */
    Assert.isNull(refreshCycleStageDataComReqDto.getCycleStageDataId(),"D3-审核汇报任务资料和标准数据(公共)-D3-3更新周期阶段资料(公共)-周期阶段资料记录ID不能为空",false);
Assert.isNull(refreshCycleStageDataComReqDto.getEvaObjTargetCycleId(),"D3-审核汇报任务资料和标准数据(公共)-D3-3更新周期阶段资料(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(refreshCycleStageDataComReqDto.getCycleId(),"D3-审核汇报任务资料和标准数据(公共)-D3-3更新周期阶段资料(公共)-周期ID不能为空",false);
      refreshCycleStageDataComRespDto = cycleStageDataService.refreshCycleStageDataCom(refreshCycleStageDataComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage 3-7-01修改任务  67686
      boolean bOOLEAN ;
    OmsTask omsTask=new OmsTask();
  omsTask.setPercentageProgress(Double.valueOf("100"));//CUSTOM_CONVENTION//sourceId:1765177_1_67686
if(reqDto!=null){
      omsTask.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1765176_1_67686
    }

    /*3-7-01修改任务[2706]   */
    Assert.isNull(omsTask.getTaskId(),"D3-审核汇报任务资料和标准数据(公共)-3-7-01修改任务-任务ID不能为空",false);
Assert.isNull(omsTask.getPercentageProgress(),"D3-审核汇报任务资料和标准数据(公共)-3-7-01修改任务-冗余最新进度不能为空",false);
      bOOLEAN = mOmsTaskService.updateTask(omsTask)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage 11111D4-审核通过标准数据(公共)  67682
      ApproveSucceedStandardDataComRespDto approveSucceedStandardDataComRespDto = null;
    ApproveSucceedStandardDataComReqDto approveSucceedStandardDataComReqDto=new ApproveSucceedStandardDataComReqDto();
  if(reqDto!=null){
      approveSucceedStandardDataComReqDto.setEventBatchUpdateCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1764655_1_67682
approveSucceedStandardDataComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1764652_1_67682
approveSucceedStandardDataComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1764653_1_67682
approveSucceedStandardDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1764654_1_67682
    }

    /*11111D4-审核通过标准数据(公共)[5687]   */
    Assert.isNull(approveSucceedStandardDataComReqDto.getEventBatchUpdateCode(),"D3-审核汇报任务资料和标准数据(公共)-11111D4-审核通过标准数据(公共)-事务内数据更新批次标识不能为空",false);
Assert.isNull(approveSucceedStandardDataComReqDto.getEvaObjTargetCycleId(),"D3-审核汇报任务资料和标准数据(公共)-11111D4-审核通过标准数据(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(approveSucceedStandardDataComReqDto.getCycleId(),"D3-审核汇报任务资料和标准数据(公共)-11111D4-审核通过标准数据(公共)-周期ID不能为空",false);
Assert.isNull(approveSucceedStandardDataComReqDto.getEvaluationTemplateId(),"D3-审核汇报任务资料和标准数据(公共)-11111D4-审核通过标准数据(公共)-冗余评价模板ID不能为空",false);
      approveSucceedStandardDataComRespDto = fwCalcStandardDataClient.approveSucceedStandardDataCom(approveSucceedStandardDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



ApproveSucceedReportTaskComRespDto retData = new ApproveSucceedReportTaskComRespDto();





return retData;
  }
/**
   * D3-根据目标周期查询目标内容父中周期(公共)[7116]
   * gen by moon at 6/2/2023, 2:58:33 PM
   */
  @Trace(operationName = "D3-根据目标周期查询目标内容父中周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementFatherAndMidTargetCycleIDComRespDto implementFatherAndMidTargetCycleIDCom(ImplementFatherAndMidTargetCycleIDComReqDto reqDto){


      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_3 =null;
OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_5 =null;
//步骤0: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
     OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1004549_1
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1004547_1
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1004548_1
    }

    /*3-3-09查目标周期详情（获取内容信息）[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期详情（获取内容信息）-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期详情（获取内容信息）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getSubjectLifeCycle(),"D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期详情（获取内容信息）-主体生命周期不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;




//步骤1: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
     OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_1.setIsParentCycle("TRUE");//sourceId:1004722_1
queryEvaObjTargetCycleDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1004724_1
if(omsEvaluationObjectTargetCycle!=null){
      queryEvaObjTargetCycleDetailReq_1.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1004717_1
queryEvaObjTargetCycleDetailReq_1.setEvaObjTableTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:1004718_1
queryEvaObjTargetCycleDetailReq_1.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1004719_1
queryEvaObjTargetCycleDetailReq_1.setTreeTypeCode(omsEvaluationObjectTargetCycle.getTreeTypeCode());//SimpleFieldAssign//sourceId:1004720_1
queryEvaObjTargetCycleDetailReq_1.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1004721_1
    }
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1004723_1
    }

    /*3-3-09查目标内容父周期[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjEntityId(),"D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标内容父周期-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTableTypeCode(),"D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标内容父周期-被评对象内容表类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTypeCode(),"D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标内容父周期-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTreeTypeCode(),"D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标内容父周期-树类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTargetCycleContentId(),"D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标内容父周期-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(),"D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标内容父周期-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getSubjectLifeCycle(),"D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标内容父周期-主体生命周期不能为空",false);
      omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


      omsEvaluationObjectTargetCycle_3 = omsEvaluationObjectTargetCycle_2;
           }

//步骤2: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
     OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_4 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_2=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_2.setIsMetaphase("TRUE");//sourceId:1004714_1
queryEvaObjTargetCycleDetailReq_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1004716_1
if(omsEvaluationObjectTargetCycle!=null){
      queryEvaObjTargetCycleDetailReq_2.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1004709_1
queryEvaObjTargetCycleDetailReq_2.setEvaObjTableTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:1004710_1
queryEvaObjTargetCycleDetailReq_2.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1004711_1
queryEvaObjTargetCycleDetailReq_2.setTreeTypeCode(omsEvaluationObjectTargetCycle.getTreeTypeCode());//SimpleFieldAssign//sourceId:1004712_1
queryEvaObjTargetCycleDetailReq_2.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1004713_1
    }
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1004715_1
    }

    /*3-3-09查目标周期中期[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjEntityId(),"D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期中期-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjTableTypeCode(),"D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期中期-被评对象内容表类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjTypeCode(),"D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期中期-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getTreeTypeCode(),"D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期中期-树类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getTargetCycleContentId(),"D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期中期-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getIsMetaphase(),"D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期中期-是否中期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaluationTemplateId(),"D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期中期-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getSubjectLifeCycle(),"D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期中期-主体生命周期不能为空",false);
      omsEvaluationObjectTargetCycle_4 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;


      omsEvaluationObjectTargetCycle_5 = omsEvaluationObjectTargetCycle_4;
           }

ImplementFatherAndMidTargetCycleIDComRespDto retData = new ImplementFatherAndMidTargetCycleIDComRespDto();
  if(omsEvaluationObjectTargetCycle_3!=null){
      retData.setFatherEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_3.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1004727_1
    }
if(omsEvaluationObjectTargetCycle_5!=null){
      retData.setMidEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_5.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1004728_1
    }




return retData;
  }



/**
   * D3分析汇报任务筛选父子中周期类型(公共)[7136]
   * gen by moon at 9/12/2024, 7:18:35 PM
   */
  @Trace(operationName = "D3分析汇报任务筛选父子中周期类型(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementComRespDto implementCom(ImplementComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 =null;
//virtualUsage M3约定父中子过程周期类型  72821
//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  receptionServiceReq.setCustomField1("PARENT_CYCLE");//CUSTOM_CONVENTION//sourceId:1999614_1_72821
receptionServiceReq.setCustomField2("MID_CYCLE");//CUSTOM_CONVENTION//sourceId:1999615_1_72821
receptionServiceReq.setCustomField3("SUB_CYCLE");//CUSTOM_CONVENTION//sourceId:1999616_1_72821
receptionServiceReq.setCustomField4("PROCESS_CYCLE");//CUSTOM_CONVENTION//sourceId:1999617_1_72821

    /*M3约定父中子过程周期类型[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D3分析汇报任务筛选父子中周期类型(公共)-M3约定父中子过程周期类型-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D3分析汇报任务筛选父子中周期类型(公共)-M3约定父中子过程周期类型-自定义字段2不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField3(),"D3分析汇报任务筛选父子中周期类型(公共)-M3约定父中子过程周期类型-自定义字段3不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField4(),"D3分析汇报任务筛选父子中周期类型(公共)-M3约定父中子过程周期类型-自定义字段4不能为空",false);
      receptionServiceRes = nbGridCalculate.implementElevenReceivingField(receptionServiceReq);



if((reqDto!= null&&  reqDto.getIsFatherCycle() !=null && reqDto.getIsFatherCycle().equals("TRUE")&&reqDto!= null&&  reqDto.getIsSubCycle() !=null && reqDto.getIsSubCycle().equals("FALSE")&&reqDto!= null&&  reqDto.getIsMetaphase() !=null && reqDto.getIsMetaphase().equals("FALSE"))) {
        //if((D3-执行父子中周期分析(公共).是否父周期 等于 是 and D3-执行父子中周期分析(公共).是否子周期 等于 否 and D3-执行父子中周期分析(公共).是否中期 等于 否))  44332

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setParentSubMidCycleType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1999186_1_44333
    }

    /*约定出参[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getParentSubMidCycleType(),"D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空",false);
      receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
    }
else if((reqDto!= null&&  reqDto.getIsFatherCycle() !=null && reqDto.getIsFatherCycle().equals("TRUE")&&reqDto!= null&&  reqDto.getIsSubCycle() !=null && reqDto.getIsSubCycle().equals("TRUE")&&reqDto!= null&&  reqDto.getIsMetaphase() !=null && reqDto.getIsMetaphase().equals("FALSE"))){
       //elseif((D3-执行父子中周期分析(公共).是否父周期 等于 是 and D3-执行父子中周期分析(公共).是否子周期 等于 是 and D3-执行父子中周期分析(公共).是否中期 等于 否))  44334

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_2=new CalculateAcceptAboveFieldsReqDto();
  if(reqDto!=null){
      receptionServiceReq_2.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1011202_1_44335
    }
if(receptionServiceRes!=null){
      receptionServiceReq_2.setParentSubMidCycleType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1999186_1_44335
    }

    /*约定出参[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getParentSubMidCycleType(),"D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空",false);
      receptionServiceRes_4 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
    }
else if((reqDto!= null&&  reqDto.getIsMetaphase() !=null && reqDto.getIsMetaphase().equals("TRUE")&&reqDto!= null&&  reqDto.getIsFatherCycle() !=null && reqDto.getIsFatherCycle().equals("FALSE")&&reqDto!= null&&  reqDto.getIsSubCycle() !=null && reqDto.getIsSubCycle().equals("FALSE"))){
       //elseif((D3-执行父子中周期分析(公共).是否中期 等于 是 and D3-执行父子中周期分析(公共).是否父周期 等于 否 and D3-执行父子中周期分析(公共).是否子周期 等于 否))  44336

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_3=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_3.setParentSubMidCycleType(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1999186_1_44337
    }

    /*约定出参[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getParentSubMidCycleType(),"D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空",false);
      receptionServiceRes_5 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_5;
    }
else if((reqDto!= null&&  reqDto.getIsSubCycle() !=null && reqDto.getIsSubCycle().equals("TRUE")&&reqDto!= null&&  reqDto.getIsFatherCycle() !=null && reqDto.getIsFatherCycle().equals("FALSE")&&reqDto!= null&&  reqDto.getIsMetaphase() !=null && reqDto.getIsMetaphase().equals("FALSE"))){
       //elseif((D3-执行父子中周期分析(公共).是否子周期 等于 是 and D3-执行父子中周期分析(公共).是否父周期 等于 否 and D3-执行父子中周期分析(公共).是否中期 等于 否))  72822

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_4=new CalculateAcceptAboveFieldsReqDto();
  if(reqDto!=null){
      receptionServiceReq_4.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1011202_1_72823
    }
if(receptionServiceRes!=null){
      receptionServiceReq_4.setParentSubMidCycleType(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1999186_1_72823
    }

    /*约定出参[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getParentSubMidCycleType(),"D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空",false);
      receptionServiceRes_6 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_4);


      receptionServiceRes_3 = receptionServiceRes_6;
    }
else if((reqDto!= null&& reqDto.getIsFatherCycle() != null &&reqDto.getIsFatherCycle().equals("FALSE") && reqDto!= null&& reqDto.getIsSubCycle() != null && reqDto.getIsSubCycle().equals("FALSE") && reqDto!= null&& reqDto.getIsMetaphase() != null && reqDto.getIsMetaphase().equals("FALSE") )){
       //elseif((D3-执行父子中周期分析(公共).是否父周期 值等于空  and D3-执行父子中周期分析(公共).是否子周期 值等于空  and D3-执行父子中周期分析(公共).是否中期 值等于空 ))  72824

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_7 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_5=new CalculateAcceptAboveFieldsReqDto();
  if(reqDto!=null){
      receptionServiceReq_5.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1011202_1_72825
    }
if(receptionServiceRes!=null){
      receptionServiceReq_5.setParentSubMidCycleType(receptionServiceRes.getCustomField4());//SimpleFieldAssign//sourceId:1999186_1_72825
    }

    /*约定出参[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_5.getParentSubMidCycleType(),"D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空",false);
      receptionServiceRes_7 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_5);


      receptionServiceRes_3 = receptionServiceRes_7;
    }
ImplementComRespDto retData = new ImplementComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setCycleId(receptionServiceRes_3.getCycleId());//SimpleFieldAssign//sourceId:1011207_1
retData.setParentSubMidCycleType(receptionServiceRes_3.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1999632_1
    }




return retData;
  }


/**
   * D3-目标过程周期的执行周期分析（新）(公共)[7139]
   * gen by moon at 6/5/2023, 8:50:14 PM
   */
  @Trace(operationName = "D3-目标过程周期的执行周期分析（新）(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTargetCycleProExecCycleAnalysisNewComRespDto implementTargetCycleProExecCycleAnalysisNewCom(ImplementTargetCycleProExecCycleAnalysisNewComReqDto reqDto){


      //virtualUsage D3-查询目标内容及目标内容扩展信息（本级无实际值标识）  44353
      QueryTargetContentAndExtendInfoDetailComRespDto queryTargetContentAndExtendInfoDetailComRespDto = null;
    QueryTargetContentAndExtendInfoDetailComReqDto queryTargetContentAndExtendInfoDetailComReqDto=new QueryTargetContentAndExtendInfoDetailComReqDto();
  if(reqDto!=null){
      queryTargetContentAndExtendInfoDetailComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1011725_1_44353
queryTargetContentAndExtendInfoDetailComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1011726_1_44353
queryTargetContentAndExtendInfoDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1011727_1_44353
    }

    /*D3-查询目标内容及目标内容扩展信息（本级无实际值标识）[6148]   */
    Assert.isNull(queryTargetContentAndExtendInfoDetailComReqDto.getTargetCycleContentTypeCode(),"D3-目标过程周期的执行周期分析（新）(公共)-D3-查询目标内容及目标内容扩展信息（本级无实际值标识）-关联目标内容类型编码不能为空",false);
Assert.isNull(queryTargetContentAndExtendInfoDetailComReqDto.getTargetCycleContentId(),"D3-目标过程周期的执行周期分析（新）(公共)-D3-查询目标内容及目标内容扩展信息（本级无实际值标识）-关联目标内容ID不能为空",false);
Assert.isNull(queryTargetContentAndExtendInfoDetailComReqDto.getEvaluationTemplateId(),"D3-目标过程周期的执行周期分析（新）(公共)-D3-查询目标内容及目标内容扩展信息（本级无实际值标识）-冗余评价模板ID不能为空",false);
      queryTargetContentAndExtendInfoDetailComRespDto = targetContentService.queryTargetContentAndExtendInfoDetailCom(queryTargetContentAndExtendInfoDetailComReqDto)/*vcase invoke isSameApp*/;



if((queryTargetContentAndExtendInfoDetailComRespDto!= null&&  queryTargetContentAndExtendInfoDetailComRespDto.getIsOpenCustomReport() !=null && queryTargetContentAndExtendInfoDetailComRespDto.getIsOpenCustomReport().equals("FALSE"))) {
        //if(D3-查询目标内容及扩展信息（是否自定义汇报及自定义执行周期）.是否开启自定义汇报 等于 否)  44354

//ModelCode: circulationCollections
        for (Object circulationCollectionsRes: new ArrayList()){ //设计工具未关联参数,请联系调整

//ModelCode: circulationEnd
        }

      }
else if((queryTargetContentAndExtendInfoDetailComRespDto!= null&&  queryTargetContentAndExtendInfoDetailComRespDto.getIsOpenCustomReport() !=null && queryTargetContentAndExtendInfoDetailComRespDto.getIsOpenCustomReport().equals("TRUE"))){
       //elseif(D3-查询目标内容及扩展信息（是否自定义汇报及自定义执行周期）.是否开启自定义汇报 等于 是)  44357

OmsExecuteCycleStage omsExecuteCycleStage = null;
    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();


    /*3-3-07查询执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq.getExecuteCycleStageId(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-执行周期阶段ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getCycleId(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getCycleStartTime(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-周期开始时间不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getCycleEndTime(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-周期结束时间不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getCycleTypeCode(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-周期类型标识不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsProcessCycleStage(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getRelateContentTypeCode(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-关联目标内容类型编码不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getRelateContentId(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-关联目标内容ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsFatherCycle(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-是否父周期不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsSubCycle(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-是否子周期不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsMetaphase(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-是否中期不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsCurrentCycle(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-是否当前周期不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsNextCycle(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-是否下一周期不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getTargetId(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-冗余目标ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsArchive(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getSubjectLifeCycle(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-主体生命周期不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getSpaceId(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-创建于空间ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getAppId(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-创建于联盟应用ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsStartCycle(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-是否开始周期不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsDefinedExecuteCycleStage(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-是否自定义执行周期阶段不能为空",false);
      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;



List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    QueryExecuteCycleStageListReq queryExecuteCycleStageListReq=new QueryExecuteCycleStageListReq();


    /*3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）[3201]   */
    Assert.isNull(queryExecuteCycleStageListReq.getEvaObjTargetCycleId(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-被评对象目标周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getCycleId(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getCycleTypeCode(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-周期类型标识不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getCycleStartTime(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-周期开始时间不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getCycleEndTime(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-周期结束时间不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getFillStartTime(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-填报开始时间不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getFillEndtTime(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-填报结束时间不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getIsProcessCycleStage(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getIsDefinedExecuteCycleStage(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-是否自定义执行周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getRelateContentTypeCode(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-关联目标内容类型编码不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getRelateContentId(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-关联目标内容ID不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getTargetId(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-冗余目标ID不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getEvaluationTemplateId(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getIsSubCycle(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-是否子周期不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getIsFatherCycle(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-是否父周期不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getIsMetaphase(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-是否中期不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getIsLastCycle(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-是否末级周期不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getSubjectLifeCycle(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-主体生命周期不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getIsArchive(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-是否存档不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getSpaceId(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-创建于空间ID不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getAppId(),"D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-创建于联盟应用ID不能为空",false);
      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageList(queryExecuteCycleStageListReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsExecuteCycleStage!= null&&  listOmsExecuteCycleStage !=null && listOmsExecuteCycleStage.size()>0)) {
        //if(3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）.执行周期阶段列表数据集条数 大于 0)  44360

//ModelCode: circulationCollections
        for (Object circulationCollectionsRes_2: new ArrayList()){ //设计工具未关联参数,请联系调整

//ModelCode: circulationEnd
        }

      }
    }
ImplementTargetCycleProExecCycleAnalysisNewComRespDto retData = new ImplementTargetCycleProExecCycleAnalysisNewComRespDto();





return retData;
  }
/**
   * D3-执行计算进度参照值元素分析(公共)[7152]
   * gen by moon at 6/6/2023, 11:11:22 PM
   */
  @Trace(operationName = "D3-执行计算进度参照值元素分析(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementActualValueCalcReferenceAnalysisComRespDto implementActualValueCalcReferenceAnalysisCom(ImplementActualValueCalcReferenceAnalysisComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 =null;
      //virtualUsage 约定：0  44537
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq.setComNumField(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:1018196_1_44537

    /*约定：0[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getComNumField(),"D3-执行计算进度参照值元素分析(公共)-约定：0-通用数值字段（整数型）不能为空",false);
      receptionServiceRes = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq);



//virtualUsage 约定：1  44538
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_1.setComNumField(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1018200_1_44538

    /*约定：1[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getComNumField(),"D3-执行计算进度参照值元素分析(公共)-约定：1-通用数值字段（整数型）不能为空",false);
      receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);



if((reqDto!= null&&  reqDto.getSchemeDataPara() !=null && reqDto.getSchemeDataPara().equals("PROCESS_TYPE")||reqDto!= null&&  reqDto.getSchemeDataPara() !=null && reqDto.getSchemeDataPara().equals("MIXED_TYPE"))) {
        //if((D3-执行计算进度参照值元素分析(公共).评价模板数据参数 等于 进度型 or D3-执行计算进度参照值元素分析(公共).评价模板数据参数 等于 混合型))  44523

if((reqDto!= null&&  reqDto.getIsAutoReport() !=null && reqDto.getIsAutoReport().equals("TRUE"))) {
        //if(D3-执行计算进度参照值元素分析(公共).是否自动汇报 等于 是)  44525

if((reqDto!= null&&  reqDto.getIsLastObjective() !=null && reqDto.getIsLastObjective().equals("TRUE")&&reqDto!= null&&  reqDto.getIsOkrPlanScene() !=null && reqDto.getIsOkrPlanScene().equals("OKR_PLAN_SCENE"))) {
        //if((D3-执行计算进度参照值元素分析(公共).是否末级指标 等于 是 and D3-执行计算进度参照值元素分析(公共).冗余开启OKR场景 等于 OKR场景))  44532

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_2=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setProgressValueCalcReference(receptionServiceRes.getComNumField());//SimpleFieldAssign//sourceId:1018193_1_44539
    }
if(receptionServiceRes_2!=null){
      receptionServiceReq_2.setProgressValueCalcReferenceAndCopy(receptionServiceRes_2.getComNumField());//SimpleFieldAssign//sourceId:1018194_1_44539
    }

    /*约定出参：进度值计算参照值元素[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes_4 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_2);


      receptionServiceRes_5 = receptionServiceRes_4;
      }
else if((reqDto!= null&&  reqDto.getIsLastObjective() !=null && reqDto.getIsLastObjective().equals("FALSE"))){
       //elseif(D3-执行计算进度参照值元素分析(公共).是否末级指标 等于 否)  44533

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_3=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_3.setProgressValueCalcReference(receptionServiceRes.getComNumField());//SimpleFieldAssign//sourceId:1018193_1_44610
    }
if(receptionServiceRes_2!=null){
      receptionServiceReq_3.setProgressValueCalcReferenceAndCopy(receptionServiceRes_2.getComNumField());//SimpleFieldAssign//sourceId:1018194_1_44610
    }

    /*约定出参：进度值计算参照值元素[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes_6 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_3);


      receptionServiceRes_5 = receptionServiceRes_6;
      }
else if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY"))){
       //elseif(D3-执行计算进度参照值元素分析(公共).关联目标内容类型编码 等于 目标分类)  44608

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_7 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_4=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_4.setProgressValueCalcReference(receptionServiceRes.getComNumField());//SimpleFieldAssign//sourceId:1018193_1_44609
    }
  if(receptionServiceRes_2!=null){
      receptionServiceReq_4.setProgressValueCalcReferenceAndCopy(receptionServiceRes_2.getComNumField());//SimpleFieldAssign//sourceId:1018194_1_44609
    }

    /*约定出参：进度值计算参照值元素[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes_7 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_4);


      receptionServiceRes_5 = receptionServiceRes_7;
    }
    }
else if((reqDto!= null&&  reqDto.getIsAutoReport() !=null && reqDto.getIsAutoReport().equals("FALSE"))){
       //elseif(D3-执行计算进度参照值元素分析(公共).是否自动汇报 等于 否)  44611

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_8 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_5=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_5.setProgressValueCalcReference(receptionServiceRes_2.getComNumField());//SimpleFieldAssign//sourceId:1018193_1_44612
    }
  if(receptionServiceRes!=null){
      receptionServiceReq_5.setProgressValueCalcReferenceAndCopy(receptionServiceRes.getComNumField());//SimpleFieldAssign//sourceId:1018194_1_44612
    }

    /*约定出参：进度值计算参照值元素[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes_8 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_5);


      receptionServiceRes_5 = receptionServiceRes_8;
    }
      }
ImplementActualValueCalcReferenceAnalysisComRespDto retData = new ImplementActualValueCalcReferenceAnalysisComRespDto();
  if(receptionServiceRes_5!=null){
      retData.setProgressValueCalcReference(receptionServiceRes_5.getProgressValueCalcReference());//SimpleFieldAssign//sourceId:1019227_1
retData.setProgressValueCalcReferenceAndCopy(receptionServiceRes_5.getProgressValueCalcReferenceAndCopy());//SimpleFieldAssign//sourceId:1019228_1
    }




return retData;
  }
/**
   * D3-执行计算目标参照值元素分析(公共)[7153]
   * gen by moon at 6/6/2023, 11:11:37 PM
   */
  @Trace(operationName = "D3-执行计算目标参照值元素分析(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementProgressValueCalcReferenceAnalysisComRespDto implementProgressValueCalcReferenceAnalysisCom(ImplementProgressValueCalcReferenceAnalysisComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 =null;
      //virtualUsage 约定：0  44549
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq.setComNumField(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:1018799_1_44549

    /*约定：0[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq);



//virtualUsage 约定：1  44550
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_1.setComNumField(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1018800_1_44550

    /*约定：1[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getComNumField(),"D3-执行计算目标参照值元素分析(公共)-约定：1-通用数值字段（整数型）不能为空",false);
      receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);



if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE")&&reqDto!= null&&  reqDto.getIsLastObjective() !=null && reqDto.getIsLastObjective().equals("FALSE")&&reqDto!= null&&  reqDto.getCalculateDataSource() !=null && reqDto.getCalculateDataSource().equals("MANUAL_FILLING"))) {
        //if((D3-执行计算目标参照值元素分析(公共).关联目标内容类型编码 等于 指标 and D3-执行计算目标参照值元素分析(公共).是否末级指标 等于 否 and D3-执行计算目标参照值元素分析(公共).计算数据来源 等于 人工填报))  44551

if((reqDto!= null&&  reqDto.getIsAutoReport() !=null && reqDto.getIsAutoReport().equals("TRUE"))) {
        //if(D3-执行计算目标参照值元素分析(公共).是否自动汇报 等于 是)  44553

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_2=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setActualValueCalcReference(receptionServiceRes.getComNumField());//SimpleFieldAssign//sourceId:1018802_1_44616
    }
if(receptionServiceRes_2!=null){
      receptionServiceReq_2.setActualValueCalcReferenceAndCopy(receptionServiceRes_2.getComNumField());//SimpleFieldAssign//sourceId:1018803_1_44616
    }

    /*约定出参：实际值计算参照值元素[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes_4 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_2);


      receptionServiceRes_5 = receptionServiceRes_4;
      }
else if((reqDto!= null&&  reqDto.getIsAutoReport() !=null && reqDto.getIsAutoReport().equals("FALSE"))){
       //elseif(D3-执行计算目标参照值元素分析(公共).是否自动汇报 等于 否)  44614

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_3=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_3.setActualValueCalcReference(receptionServiceRes_2.getComNumField());//SimpleFieldAssign//sourceId:1018802_1_44615
    }
if(receptionServiceRes!=null){
      receptionServiceReq_3.setActualValueCalcReferenceAndCopy(receptionServiceRes.getComNumField());//SimpleFieldAssign//sourceId:1018803_1_44615
    }

    /*约定出参：实际值计算参照值元素[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes_6 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_3);


      receptionServiceRes_5 = receptionServiceRes_6;
      }
      }
ImplementProgressValueCalcReferenceAnalysisComRespDto retData = new ImplementProgressValueCalcReferenceAnalysisComRespDto();
  if(receptionServiceRes_5!=null){
      retData.setActualValueCalcReference(receptionServiceRes_5.getActualValueCalcReference());//SimpleFieldAssign//sourceId:1019223_1
retData.setActualValueCalcReferenceAndCopy(receptionServiceRes_5.getActualValueCalcReferenceAndCopy());//SimpleFieldAssign//sourceId:1019224_1
    }




return retData;
  }
/**
   * D3-执行周期阶段资料处理(公共)[7156]
   * gen by moon at 1/2/2024, 8:42:04 PM
   */
  @Trace(operationName = "D3-执行周期阶段资料处理(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCycleStageDataComRespDto implementCycleStageDataCom(ImplementCycleStageDataComReqDto reqDto){


      //virtualUsage D2-3查评价模板数据参数  44658
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:1020937_1_44658
queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("SCHEME_DATA_PARA");//CUSTOM_CONVENTION//sourceId:1020936_1_44658
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1020945_1_44658
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1020938_1_44658
    }

    /*D2-3查评价模板数据参数[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3-执行周期阶段资料处理(公共)-D2-3查评价模板数据参数-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(),"D3-执行周期阶段资料处理(公共)-D2-3查评价模板数据参数-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3-执行周期阶段资料处理(公共)-D2-3查评价模板数据参数-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3-执行周期阶段资料处理(公共)-D2-3查评价模板数据参数-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage D3获取目标内容属性信息（是否开启主观评价）  46967
      ObtainTargetContNatureInfoComRespDto obtainTargetContNatureInfoComRespDto = null;
    ObtainTargetContNatureInfoComReqDto obtainTargetContNatureInfoComReqDto=new ObtainTargetContNatureInfoComReqDto();
if(reqDto!=null){
      obtainTargetContNatureInfoComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1077203_1_46967
obtainTargetContNatureInfoComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1077204_1_46967
obtainTargetContNatureInfoComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1077205_1_46967
    }

    /*D3获取目标内容属性信息（是否开启主观评价）[6952]   */
    Assert.isNull(obtainTargetContNatureInfoComReqDto.getTargetCycleContentId(),"D3-执行周期阶段资料处理(公共)-D3获取目标内容属性信息（是否开启主观评价）-关联目标内容ID不能为空",false);
Assert.isNull(obtainTargetContNatureInfoComReqDto.getTargetCycleContentTypeCode(),"D3-执行周期阶段资料处理(公共)-D3获取目标内容属性信息（是否开启主观评价）-关联目标内容类型编码不能为空",false);
      obtainTargetContNatureInfoComRespDto = indexSystemService.obtainTargetContNatureInfoCom(obtainTargetContNatureInfoComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage 3-3-11查询周期阶段资料列表  44662
      List<OmsTspeCycleStageData> listOmsTspeCycleStageData =new ArrayList<>();
    QueryCycleStageDataListReq queryCycleStageDataListReq=new QueryCycleStageDataListReq();
  queryCycleStageDataListReq.setCycleDataTypeCode("CYC_STA_DAT");//sourceId:1020925_1_44662
queryCycleStageDataListReq.setCyclePurposeTypeCode("OBS_TAR_REP");//sourceId:1020928_1_44662
queryCycleStageDataListReq.setCycleDataObjTypeCode("EVA_OBJ_TARGET_CYCLE");//sourceId:1020929_1_44662
queryCycleStageDataListReq.setSubjectLifeCycle("EDITING");//sourceId:1020932_1_44662
if(reqDto!=null){
      queryCycleStageDataListReq.setCycleDataObjId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1020930_1_44662
queryCycleStageDataListReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1020933_1_44662
    }

    /*3-3-11查询周期阶段资料列表[2673]   */
    Assert.isNull(queryCycleStageDataListReq.getCycleDataObjId(),"D3-执行周期阶段资料处理(公共)-3-3-11查询周期阶段资料列表-周期资料归属对象ID不能为空",false);
Assert.isNull(queryCycleStageDataListReq.getCycleId(),"D3-执行周期阶段资料处理(公共)-3-3-11查询周期阶段资料列表-周期ID不能为空",false);
Assert.isNull(queryCycleStageDataListReq.getCycleDataTypeCode(),"D3-执行周期阶段资料处理(公共)-3-3-11查询周期阶段资料列表-周期阶段资料类型编码不能为空",false);
Assert.isNull(queryCycleStageDataListReq.getCyclePurposeTypeCode(),"D3-执行周期阶段资料处理(公共)-3-3-11查询周期阶段资料列表-周期资料用途类型编码不能为空",false);
Assert.isNull(queryCycleStageDataListReq.getCycleDataObjTypeCode(),"D3-执行周期阶段资料处理(公共)-3-3-11查询周期阶段资料列表-周期资料归属对象类型编码不能为空",false);
Assert.isNull(queryCycleStageDataListReq.getSubjectLifeCycle(),"D3-执行周期阶段资料处理(公共)-3-3-11查询周期阶段资料列表-主体生命周期不能为空",false);
      listOmsTspeCycleStageData = mOmsTspeCycleStageDataService.queryCycleStageDataList(queryCycleStageDataListReq)/*vcase invoke 本地 method 方法调用;*/;



if((queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("DOC_TYPE")||obtainTargetContNatureInfoComRespDto!= null&&  obtainTargetContNatureInfoComRespDto.getIsSubjectiveScoring() !=null && obtainTargetContNatureInfoComRespDto.getIsSubjectiveScoring().equals("FALSE"))) {
        //if((D2-3查评价模板数据参数.答案值 等于 资料型 or D3获取目标内容属性信息（是否开启主观评价）.是否开启主观评分 等于 否))  44660

boolean bOOLEAN ;
    if(listOmsTspeCycleStageData !=null&& !CollectionUtil.isEmpty(listOmsTspeCycleStageData)&& listOmsTspeCycleStageData.size()>0 ){
          List<OmsTspeCycleStageData> listOmsTspeCycleStageData_2=new ArrayList<>();
  if(listOmsTspeCycleStageData!= null&& !CollectionUtil.isEmpty(listOmsTspeCycleStageData)&&  listOmsTspeCycleStageData !=null&& !CollectionUtil.isEmpty(listOmsTspeCycleStageData)){
      listOmsTspeCycleStageData_2 = //objList-to-objLists
        listOmsTspeCycleStageData.stream().map(item -> {
      OmsTspeCycleStageData elm = new OmsTspeCycleStageData();
      elm.setCycleStageDataId(item.getCycleStageDataId());//SimpleFieldAssign//sourceId:217239_2_44663
elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:217241_2_44663
elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:217243_2_44663
elm.setActualEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:217249_2_44663
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1020970_1_44663
    }

    /*3-3-11批量修改周期阶段资料（无评价）[3342]   */

      bOOLEAN = mOmsTspeCycleStageDataService.batchUpdateCycleStageData(listOmsTspeCycleStageData_2)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
else if((!(queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("DOC_TYPE"))&&obtainTargetContNatureInfoComRespDto!= null&&  obtainTargetContNatureInfoComRespDto.getIsSubjectiveScoring() !=null && obtainTargetContNatureInfoComRespDto.getIsSubjectiveScoring().equals("TRUE"))){
       //elseif((D2-3查评价模板数据参数.答案值 不等于 资料型 and D3获取目标内容属性信息（是否开启主观评价）.是否开启主观评分 等于 是))  44661

boolean bOOLEAN_1 ;
    if(listOmsTspeCycleStageData !=null&& !CollectionUtil.isEmpty(listOmsTspeCycleStageData)&& listOmsTspeCycleStageData.size()>0 ){
          List<OmsTspeCycleStageData> listOmsTspeCycleStageData_3=new ArrayList<>();
  if(listOmsTspeCycleStageData!= null&& !CollectionUtil.isEmpty(listOmsTspeCycleStageData)&&  listOmsTspeCycleStageData !=null&& !CollectionUtil.isEmpty(listOmsTspeCycleStageData)){
      listOmsTspeCycleStageData_3 = //objList-to-objLists
        listOmsTspeCycleStageData.stream().map(item -> {
      OmsTspeCycleStageData elm = new OmsTspeCycleStageData();
      elm.setCycleStageDataId(item.getCycleStageDataId());//SimpleFieldAssign//sourceId:217230_2_44664
elm.setActualEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:217250_2_44664
elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:217232_2_44664
elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:217234_2_44664
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1020935_1_44664
    }

    /*3-3-11批量修改周期阶段资料（待评价）[3342]   */

      bOOLEAN_1 = mOmsTspeCycleStageDataService.batchUpdateCycleStageData(listOmsTspeCycleStageData_3)/*vcase invoke 本地 method 方法调用;*/;



    }
      }
ImplementCycleStageDataComRespDto retData = new ImplementCycleStageDataComRespDto();





return retData;
  }
/**
   * D3-分析最新可循环周期标准数据(公共)[7184]
   * gen by moon at 7/12/2023, 9:52:53 PM
   */
  @Trace(operationName = "D3-分析最新可循环周期标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAnalysisCurrentCycleIsUpdateCycleComRespDto implementAnalysisCurrentCycleIsUpdateCycleCom(ImplementAnalysisCurrentCycleIsUpdateCycleComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 =null;
//virtualUsage D2-执行字符串对比(公共)  45058
      ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto = null;
    ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto=new ImplementStringEfficiencyCheckComReqDto();
  if(reqDto!=null){
      implementStringEfficiencyCheckComReqDto.setReferenceString(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1030734_1_45058
implementStringEfficiencyCheckComReqDto.setComparisonString(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1030735_1_45058
    }

    /*D2-执行字符串对比(公共)[5774]   */

      implementStringEfficiencyCheckComRespDto = fwCompInterfaceModeClient.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((implementStringEfficiencyCheckComRespDto!= null&&  implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("FALSE"))) {
        //if(D2-判断更新周期ID是否等于归属周期ID.字符串对比结果 等于 否)  45059

ImplementFindSubTargetCycleComRespDto implementFindSubTargetCycleComRespDto = null;
    ImplementFindSubTargetCycleComReqDto implementFindSubTargetCycleComReqDto=new ImplementFindSubTargetCycleComReqDto();
  if(reqDto!=null){
      implementFindSubTargetCycleComReqDto.setStandardDataCalcCycleModel(reqDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1049790_1_45870
implementFindSubTargetCycleComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1049791_1_45870
implementFindSubTargetCycleComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1049792_1_45870
implementFindSubTargetCycleComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1049793_1_45870
implementFindSubTargetCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1049794_1_45870
    }

    /*D3-执行获取目标内容子周期(公共)[7120]   */

      implementFindSubTargetCycleComRespDto = implementFindSubTargetCycleCom(implementFindSubTargetCycleComReqDto)/*vcase invoke 同服务,同domain*/;



QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
    if(implementFindSubTargetCycleComRespDto !=null){
    QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto=new QueryStandardDataDetailComReqDto();
  queryStandardDataDetailComReqDto.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1077349_1_45871
  queryStandardDataDetailComReqDto.setIsNewData("TRUE");//sourceId:1031012_1_45871
if(implementFindSubTargetCycleComRespDto!=null){
      queryStandardDataDetailComReqDto.setEntityId(implementFindSubTargetCycleComRespDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1031009_1_45871
    }
if(reqDto!=null){
      queryStandardDataDetailComReqDto.setPeriodId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1031007_1_45871
queryStandardDataDetailComReqDto.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1031010_1_45871
queryStandardDataDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1031013_1_45871
    }

    /*D4-1查标准数据详情(公共)[2695]   */
    Assert.isNull(queryStandardDataDetailComReqDto.getEntityId(),"D3-分析最新可循环周期标准数据(公共)-D4-1查标准数据详情(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getPeriodId(),"D3-分析最新可循环周期标准数据(公共)-D4-1查标准数据详情(公共)-周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getDataType(),"D3-分析最新可循环周期标准数据(公共)-D4-1查标准数据详情(公共)-数据点类型不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getDataUsageSceneCode(),"D3-分析最新可循环周期标准数据(公共)-D4-1查标准数据详情(公共)-数据业务场景不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getIsNewData(),"D3-分析最新可循环周期标准数据(公共)-D4-1查标准数据详情(公共)-是否归属周期最新数据不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentId(),"D3-分析最新可循环周期标准数据(公共)-D4-1查标准数据详情(公共)-主题内容ID不能为空",false);
      queryStandardDataDetailComRespDto = fwCalcStandardDataClient.queryStandardDataDetailCom(queryStandardDataDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    if(queryStandardDataDetailComRespDto !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  if(queryStandardDataDetailComRespDto!=null){
      receptionServiceReq.setDataResultId(queryStandardDataDetailComRespDto.getDataResultId());//SimpleFieldAssign//sourceId:1030985_1_45872
    }

    /*约定出参：数据结果ID[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((implementStringEfficiencyCheckComRespDto!= null&&  implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("TRUE"))){
       //elseif(D2-判断更新周期ID是否等于归属周期ID.字符串对比结果 等于 是)  45060

ImplementNextCyclePeriodStandardDataComRespDto implementNextCyclePeriodStandardDataComRespDto = null;
    ImplementNextCyclePeriodStandardDataComReqDto implementNextCyclePeriodStandardDataComReqDto=new ImplementNextCyclePeriodStandardDataComReqDto();
  if(reqDto!=null){
      implementNextCyclePeriodStandardDataComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1030737_1_45063
implementNextCyclePeriodStandardDataComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1030738_1_45063
implementNextCyclePeriodStandardDataComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1085671_1_45063
implementNextCyclePeriodStandardDataComReqDto.setLastCycleType(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:1030739_1_45063
implementNextCyclePeriodStandardDataComReqDto.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1030741_1_45063
implementNextCyclePeriodStandardDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1030740_1_45063
    }

    /*D4-执行最近可循环周期标准数据分析(公共)[6207]   */
    Assert.isNull(implementNextCyclePeriodStandardDataComReqDto.getEvaObjTargetCycleId(),"D3-分析最新可循环周期标准数据(公共)-D4-执行最近可循环周期标准数据分析(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementNextCyclePeriodStandardDataComReqDto.getCycleId(),"D3-分析最新可循环周期标准数据(公共)-D4-执行最近可循环周期标准数据分析(公共)-周期ID不能为空",false);
Assert.isNull(implementNextCyclePeriodStandardDataComReqDto.getLastCycleType(),"D3-分析最新可循环周期标准数据(公共)-D4-执行最近可循环周期标准数据分析(公共)-末级周期类型不能为空",false);
Assert.isNull(implementNextCyclePeriodStandardDataComReqDto.getDataType(),"D3-分析最新可循环周期标准数据(公共)-D4-执行最近可循环周期标准数据分析(公共)-数据点类型不能为空",false);
Assert.isNull(implementNextCyclePeriodStandardDataComReqDto.getEvaluationTemplateId(),"D3-分析最新可循环周期标准数据(公共)-D4-执行最近可循环周期标准数据分析(公共)-冗余评价模板ID不能为空",false);
      implementNextCyclePeriodStandardDataComRespDto = fwCalcStandardDataClient.implementNextCyclePeriodStandardDataCom(implementNextCyclePeriodStandardDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



CalculateNewestOfMultipleNumServiceComRespDto calculateNewestOfMultipleNumServiceComRespDto = null;
    if(implementNextCyclePeriodStandardDataComRespDto !=null){
          CalculateNewestOfMultipleNumServiceComReqDto calculateNewestOfMultipleNumServiceComReqDto=new CalculateNewestOfMultipleNumServiceComReqDto();
  if(reqDto!=null){
      calculateNewestOfMultipleNumServiceComReqDto.setDecimalPointRules(reqDto.getDecimalPointRules());//SimpleFieldAssign//sourceId:1030996_1_45067
calculateNewestOfMultipleNumServiceComReqDto.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1030997_1_45067
    }
if(implementNextCyclePeriodStandardDataComRespDto!= null&&  implementNextCyclePeriodStandardDataComRespDto.getStandardDataList() !=null&& !CollectionUtil.isEmpty(implementNextCyclePeriodStandardDataComRespDto.getStandardDataList())){
      calculateNewestOfMultipleNumServiceComReqDto.setNewestOfMultipleNumList(//objList-to-objLists
        implementNextCyclePeriodStandardDataComRespDto.getStandardDataList().stream().map(item -> {
      NewestOfMultipleNumDto elm = new NewestOfMultipleNumDto();
      if(item!=null){
      elm.setCommPrimaryKey(item.getDataResultId());//SimpleFieldAssign//sourceId:219220_2_45067
elm.setCalcPara1(item.getDataResult());//SimpleFieldAssign//sourceId:219222_2_45067
elm.setComTimeField(item.getReleaseTime());//SimpleFieldAssign//sourceId:219221_2_45067
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1030994_1_45067
    }

    /*D4-计算数据集取最新服务(公共)[3430]   */

      calculateNewestOfMultipleNumServiceComRespDto = fwCalcCalculationRulesClient.calculateNewestOfMultipleNumServiceCom(calculateNewestOfMultipleNumServiceComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    if(calculateNewestOfMultipleNumServiceComRespDto !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  if(calculateNewestOfMultipleNumServiceComRespDto!=null){
      receptionServiceReq_1.setDataResultId(calculateNewestOfMultipleNumServiceComRespDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1030985_1_45068
    }

    /*约定出参：数据结果ID[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
ImplementAnalysisCurrentCycleIsUpdateCycleComRespDto retData = new ImplementAnalysisCurrentCycleIsUpdateCycleComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setDataResultId(receptionServiceRes_1.getDataResultId());//SimpleFieldAssign//sourceId:1031015_1
    }




return retData;
  }
/**
   * D3-根据是否自定义汇报分析目标内容ID(公共)[7188]
   * gen by moon at 6/11/2023, 6:43:46 AM
   */
  @Trace(operationName = "D3-根据是否自定义汇报分析目标内容ID(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementGetTargetContentIdComRespDto implementGetTargetContentIdCom(ImplementGetTargetContentIdComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 =null;
//virtualUsage 3-2-02查评价模板详情  45120
      OmsEvaluationTemplate omsEvaluationTemplate = null;
    QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
  queryEvaTempDetailReq.setIsArchive("FALSE");//sourceId:1033435_1_45120
if(reqDto!=null){
      queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1033434_1_45120
    }

    /*3-2-02查评价模板详情[2316]   */
    Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(),"D3-根据是否自定义汇报分析目标内容ID(公共)-3-2-02查评价模板详情-评价模板ID不能为空",false);
Assert.isNull(queryEvaTempDetailReq.getIsArchive(),"D3-根据是否自定义汇报分析目标内容ID(公共)-3-2-02查评价模板详情-是否存档不能为空",false);
      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET"))) {
        //if(D3-根据是否自定义汇报分析目标内容ID(公共).关联目标内容类型编码 等于 目标)  45101

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    if(omsEvaluationTemplate !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  if(omsEvaluationTemplate!=null){
      receptionServiceReq.setTargetCycleContentId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:1032986_1_45109
    }

    /*约定出参：目标内容&目标内容ID[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTargetCycleContentId(),"D3-根据是否自定义汇报分析目标内容ID(公共)-约定出参：目标内容&目标内容ID-关联目标内容ID不能为空",false);
      receptionServiceRes = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY"))){
       //elseif(D3-根据是否自定义汇报分析目标内容ID(公共).关联目标内容类型编码 等于 目标分类)  45102

OmsTargetCategoryExtend omsTargetCategoryExtend = null;
    QueryTargetCatExSetDetailReq queryTargetCatExSetDetailReq=new QueryTargetCatExSetDetailReq();
  queryTargetCatExSetDetailReq.setIsArchive("FALSE");//sourceId:1033114_1_45107
if(reqDto!=null){
      queryTargetCatExSetDetailReq.setTargetCategoryId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1033104_1_45107
queryTargetCatExSetDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1033113_1_45107
    }

    /*3-3-02-01查询目标分类扩展设置详情[3294]   */
    Assert.isNull(queryTargetCatExSetDetailReq.getTargetCategoryId(),"D3-根据是否自定义汇报分析目标内容ID(公共)-3-3-02-01查询目标分类扩展设置详情-归属目标分类ID不能为空",false);
Assert.isNull(queryTargetCatExSetDetailReq.getEvaluationTemplateId(),"D3-根据是否自定义汇报分析目标内容ID(公共)-3-3-02-01查询目标分类扩展设置详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCatExSetDetailReq.getIsArchive(),"D3-根据是否自定义汇报分析目标内容ID(公共)-3-3-02-01查询目标分类扩展设置详情-是否存档不能为空",false);
      omsTargetCategoryExtend = mOmsTargetCategoryExtendService.queryTargetCatExSetDetail(queryTargetCatExSetDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsTargetCategoryExtend!= null&&  omsTargetCategoryExtend.getIsOpenCustomReport() !=null && omsTargetCategoryExtend.getIsOpenCustomReport().equals("TRUE")||omsTargetCategoryExtend!= null&&  omsTargetCategoryExtend.getIsOpenCustomExecuteCycle() !=null && omsTargetCategoryExtend.getIsOpenCustomExecuteCycle().equals("TRUE"))) {
        //if((3-3-02-01查目标分类是否自定义汇报或自定义执行周期.是否开启自定义汇报 等于 是 or 3-3-02-01查目标分类是否自定义汇报或自定义执行周期.是否开启自定义执行周期 等于 是))  45110

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  if(reqDto!=null){
      receptionServiceReq_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1032986_1_45111
    }

    /*约定出参：目标内容&目标内容ID[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getTargetCycleContentId(),"D3-根据是否自定义汇报分析目标内容ID(公共)-约定出参：目标内容&目标内容ID-关联目标内容ID不能为空",false);
      receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
      }
else if((omsTargetCategoryExtend!= null&&  omsTargetCategoryExtend.getIsOpenCustomReport() !=null && omsTargetCategoryExtend.getIsOpenCustomReport().equals("FALSE")&&omsTargetCategoryExtend!= null&&  omsTargetCategoryExtend.getIsOpenCustomExecuteCycle() !=null && omsTargetCategoryExtend.getIsOpenCustomExecuteCycle().equals("FALSE"))){
       //elseif((3-3-02-01查目标分类是否自定义汇报或自定义执行周期.是否开启自定义汇报 等于 否 and 3-3-02-01查目标分类是否自定义汇报或自定义执行周期.是否开启自定义执行周期 等于 否))  45112

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 = null;
    if(omsEvaluationTemplate !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq_2=new CalculateAcceptAboveFieldsReqDto();
  if(omsEvaluationTemplate!=null){
      receptionServiceReq_2.setTargetCycleContentId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:1032986_1_45114
    }

    /*约定出参：目标内容&目标内容ID[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getTargetCycleContentId(),"D3-根据是否自定义汇报分析目标内容ID(公共)-约定出参：目标内容&目标内容ID-关联目标内容ID不能为空",false);
      receptionServiceRes_3 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_3;
           }
    }
    }
else if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))){
       //elseif(D3-根据是否自定义汇报分析目标内容ID(公共).关联目标内容类型编码 等于 指标)  45103

OmsTargetObjectivePlanExtend omsTargetObjectivePlanExtend = null;
    QueryTargetObjPlanExDetailReq queryTargetObjPlanExDetailReq=new QueryTargetObjPlanExDetailReq();
  queryTargetObjPlanExDetailReq.setIsArchive("FALSE");//sourceId:1033130_1_45108
if(reqDto!=null){
      queryTargetObjPlanExDetailReq.setObjectiveId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1033117_1_45108
queryTargetObjPlanExDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1033138_1_45108
    }

    /*3-3-05查指标扩展规划设置详情[2725]   */
    Assert.isNull(queryTargetObjPlanExDetailReq.getObjectiveId(),"D3-根据是否自定义汇报分析目标内容ID(公共)-3-3-05查指标扩展规划设置详情-归属指标ID不能为空",false);
Assert.isNull(queryTargetObjPlanExDetailReq.getEvaluationTemplateId(),"D3-根据是否自定义汇报分析目标内容ID(公共)-3-3-05查指标扩展规划设置详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetObjPlanExDetailReq.getIsArchive(),"D3-根据是否自定义汇报分析目标内容ID(公共)-3-3-05查指标扩展规划设置详情-是否存档不能为空",false);
      omsTargetObjectivePlanExtend = mOmsTargetObjectivePlanExtendService.queryTargetObjPlanExDetail(queryTargetObjPlanExDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsTargetObjectivePlanExtend!= null&&  omsTargetObjectivePlanExtend.getIsOpenCustomReport() !=null && omsTargetObjectivePlanExtend.getIsOpenCustomReport().equals("TRUE")||omsTargetObjectivePlanExtend!= null&&  omsTargetObjectivePlanExtend.getIsOpenCustomExecuteCycle() !=null && omsTargetObjectivePlanExtend.getIsOpenCustomExecuteCycle().equals("TRUE"))) {
        //if((3-3-05查指标是否自定义汇报或自定义执行周期.是否开启自定义汇报 等于 是 or 3-3-05查指标是否自定义汇报或自定义执行周期.是否开启自定义执行周期 等于 是))  45115

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_3=new CalculateAcceptAboveFieldsReqDto();
  if(reqDto!=null){
      receptionServiceReq_3.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1032986_1_45116
    }

    /*约定出参：目标内容&目标内容ID[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getTargetCycleContentId(),"D3-根据是否自定义汇报分析目标内容ID(公共)-约定出参：目标内容&目标内容ID-关联目标内容ID不能为空",false);
      receptionServiceRes_4 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_3);


      receptionServiceRes_1 = receptionServiceRes_4;
      }
else if((omsTargetObjectivePlanExtend!= null&&  omsTargetObjectivePlanExtend.getIsOpenCustomReport() !=null && omsTargetObjectivePlanExtend.getIsOpenCustomReport().equals("FALSE")&&omsTargetObjectivePlanExtend!= null&&  omsTargetObjectivePlanExtend.getIsOpenCustomExecuteCycle() !=null && omsTargetObjectivePlanExtend.getIsOpenCustomExecuteCycle().equals("FALSE"))){
       //elseif((3-3-05查指标是否自定义汇报或自定义执行周期.是否开启自定义汇报 等于 否 and 3-3-05查指标是否自定义汇报或自定义执行周期.是否开启自定义执行周期 等于 否))  45117

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 = null;
    if(omsEvaluationTemplate !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq_4=new CalculateAcceptAboveFieldsReqDto();
  if(omsEvaluationTemplate!=null){
      receptionServiceReq_4.setTargetCycleContentId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:1032986_1_45118
    }

    /*约定出参：目标内容&目标内容ID[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getTargetCycleContentId(),"D3-根据是否自定义汇报分析目标内容ID(公共)-约定出参：目标内容&目标内容ID-关联目标内容ID不能为空",false);
      receptionServiceRes_5 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_4);


      receptionServiceRes_1 = receptionServiceRes_5;
           }
    }
    }
ImplementGetTargetContentIdComRespDto retData = new ImplementGetTargetContentIdComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setTargetCycleContentId(receptionServiceRes_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1033396_1
    }




return retData;
  }

/**
   * D3-新增托底网格计算调度(公共)[7215]
   * gen by moon at 6/20/2023, 6:20:32 PM
   */
  @Trace(operationName = "D3-新增托底网格计算调度(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddUnderpinningCalcGridDispatchComRespDto addUnderpinningCalcGridDispatchCom(AddUnderpinningCalcGridDispatchComReqDto reqDto){


      ImplementAcceptFieldRespDto receptionServiceRes_1 =null;
//virtualUsage D3获取执行进度信息(公共)  45554
      ObtainStatisticsUpdateExecuteProgressComRespDto obtainExecuteProgressComRespDto = null;
      ObtainStatisticsUpdateExecuteProgressComReqDto obtainExecuteProgressComReqDto=new ObtainStatisticsUpdateExecuteProgressComReqDto();
  obtainExecuteProgressComReqDto.setObjectTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1042708_1_45554
obtainExecuteProgressComReqDto.setUseTypeCode("USE_ALL_TEMP_CALCULATE");//CUSTOM_CONVENTION//sourceId:1042710_1_45554
obtainExecuteProgressComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1042716_1_45554
obtainExecuteProgressComReqDto.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1042712_1_45554
obtainExecuteProgressComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1042714_1_45554
obtainExecuteProgressComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:1042715_1_45554
if(reqDto!=null){
      obtainExecuteProgressComReqDto.setObjectId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1042709_1_45554
obtainExecuteProgressComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1042711_1_45554
    }

    /*D3获取执行进度信息(公共)[7207]   */
    Assert.isNull(obtainExecuteProgressComReqDto.getObjectTypeCode(),"D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-归属对象类型编码不能为空",false);
Assert.isNull(obtainExecuteProgressComReqDto.getObjectId(),"D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-归属对象内容ID不能为空",false);
Assert.isNull(obtainExecuteProgressComReqDto.getUseTypeCode(),"D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-用途类型编码不能为空",false);
Assert.isNull(obtainExecuteProgressComReqDto.getThemeContentTypeCode(),"D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-主题内容类型编码不能为空",false);
Assert.isNull(obtainExecuteProgressComReqDto.getThemeContentId(),"D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-主题内容ID不能为空",false);
Assert.isNull(obtainExecuteProgressComReqDto.getOperationInductionId(),"D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-操作人就职记录ID不能为空",false);
Assert.isNull(obtainExecuteProgressComReqDto.getSpaceId(),"D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-创建于空间ID不能为空",false);
Assert.isNull(obtainExecuteProgressComReqDto.getAppId(),"D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-创建于联盟应用ID不能为空",false);
      obtainExecuteProgressComRespDto = executeProgressService.obtainStatisticsUpdateExecuteProgressCom(obtainExecuteProgressComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage 3-2-09查未完成的全网格计算标准数据调度是否存在  45538
      OmsTargetTimingTaskDispatch omsTargetTimingTaskDispatch = null;
    QueryTimerTaskPlanDetailReq queryTimerTaskPlanDetailReq=new QueryTimerTaskPlanDetailReq();
  queryTimerTaskPlanDetailReq.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:1041769_1_45538
queryTimerTaskPlanDetailReq.setDispatchActionTypeCode("DISPATCH_EXECUTE_GRID_CALC_TASK");//sourceId:1041770_1_45538
queryTimerTaskPlanDetailReq.setIsComplete("FALSE");//sourceId:1041773_1_45538
queryTimerTaskPlanDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1041774_1_45538
if(reqDto!=null){
      queryTimerTaskPlanDetailReq.setObjectId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1041771_1_45538
queryTimerTaskPlanDetailReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1041772_1_45538
    }

    /*3-2-09查未完成的全网格计算标准数据调度是否存在[3187]   */
    Assert.isNull(queryTimerTaskPlanDetailReq.getTaskDispatchTypeCode(),"D3-新增托底网格计算调度(公共)-3-2-09查未完成的全网格计算标准数据调度是否存在-任务调度类型编码不能为空",false);
Assert.isNull(queryTimerTaskPlanDetailReq.getDispatchActionTypeCode(),"D3-新增托底网格计算调度(公共)-3-2-09查未完成的全网格计算标准数据调度是否存在-任务调度的行为类型编码不能为空",false);
Assert.isNull(queryTimerTaskPlanDetailReq.getObjectId(),"D3-新增托底网格计算调度(公共)-3-2-09查未完成的全网格计算标准数据调度是否存在-归属对象内容ID不能为空",false);
Assert.isNull(queryTimerTaskPlanDetailReq.getThemeContentId(),"D3-新增托底网格计算调度(公共)-3-2-09查未完成的全网格计算标准数据调度是否存在-主题内容ID不能为空",false);
Assert.isNull(queryTimerTaskPlanDetailReq.getIsComplete(),"D3-新增托底网格计算调度(公共)-3-2-09查未完成的全网格计算标准数据调度是否存在-是否执行完成不能为空",false);
Assert.isNull(queryTimerTaskPlanDetailReq.getSpaceId(),"D3-新增托底网格计算调度(公共)-3-2-09查未完成的全网格计算标准数据调度是否存在-创建于空间ID不能为空",false);
      omsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanDetail(queryTimerTaskPlanDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsTargetTimingTaskDispatch == null ||!(obtainExecuteProgressComRespDto!= null&&  obtainExecuteProgressComRespDto.getAsyncExecuteState() !=null && obtainExecuteProgressComRespDto.getAsyncExecuteState().equals("IN_PROGRESS")))) {
        //if((3-2-09查未完成的全网格计算标准数据调度是否存在.出参 值等于空  or D3获取执行进度信息(公共).异步执行状态 不等于 进行中))  45539

OmsEvaluationTemplate omsEvaluationTemplate = null;
    QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
  queryEvaTempDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1041895_1_45541
if(reqDto!=null){
      queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1041894_1_45541
      queryEvaTempDetailReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1041922_1_45541
    }

    /*3-2-02查评价模板简称[2316]   */
    Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(),"D3-新增托底网格计算调度(公共)-3-2-02查评价模板简称-评价模板ID不能为空",false);
Assert.isNull(queryEvaTempDetailReq.getTargetId(),"D3-新增托底网格计算调度(公共)-3-2-02查评价模板简称-对应的目标ID不能为空",false);
Assert.isNull(queryEvaTempDetailReq.getSubjectLifeCycle(),"D3-新增托底网格计算调度(公共)-3-2-02查评价模板简称-主体生命周期不能为空",false);
      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;



OmsCycle omsCycle = null;
    QueryCycleDetailReq queryCycleDetailReq=new QueryCycleDetailReq();
  queryCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1041953_1_45542
if(reqDto!=null){
      queryCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1041952_1_45542
    }

    /*3-4-04查周期名称[2004]   */
    Assert.isNull(queryCycleDetailReq.getCycleId(),"D3-新增托底网格计算调度(公共)-3-4-04查周期名称-周期ID不能为空",false);
Assert.isNull(queryCycleDetailReq.getSubjectLifeCycle(),"D3-新增托底网格计算调度(公共)-3-4-04查周期名称-主体生命周期不能为空",false);
      omsCycle = mOmsCycleService.queryCycleDetail(queryCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



AddTimerTaskPlanComRespDto addTimerTaskPlanComRespDto = null;
    if(omsCycle !=null&&omsEvaluationTemplate !=null&&obtainExecuteProgressComRespDto !=null){
          AddTimerTaskPlanComReqDto addTimerTaskPlanComReqDto=new AddTimerTaskPlanComReqDto();
  addTimerTaskPlanComReqDto.setIsCompensateTask("FALSE");//sourceId:1041776_1_45540
addTimerTaskPlanComReqDto.setDispatchActionTypeCode("DISPATCH_EXECUTE_GRID_CALC_TASK");//sourceId:1041777_1_45540
addTimerTaskPlanComReqDto.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:1041778_1_45540
addTimerTaskPlanComReqDto.setObjectTypeCode("OMS_TARGET");//sourceId:1041779_1_45540
addTimerTaskPlanComReqDto.setAddRuleInfoTypeCode("OMS_CYCLE");//sourceId:1041782_1_45540
addTimerTaskPlanComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1041796_1_45540
addTimerTaskPlanComReqDto.setIsAppointSimpleMq("FALSE");//sourceId:1041793_1_45540
addTimerTaskPlanComReqDto.setIsComplete("FALSE");//sourceId:1041791_1_45540
addTimerTaskPlanComReqDto.setIsRealTimeaSync("TRUE");//sourceId:1041802_1_45540
addTimerTaskPlanComReqDto.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1041788_1_45540
addTimerTaskPlanComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1041789_1_45540
addTimerTaskPlanComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:1041790_1_45540
if(omsCycle!=null){
      addTimerTaskPlanComReqDto.setCycleStandardName(omsCycle.getCycleStandardName());//SimpleFieldAssign//sourceId:1041957_1_45540
    }
if(omsEvaluationTemplate!=null){
      addTimerTaskPlanComReqDto.setTargetContentName(omsEvaluationTemplate.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:1041956_1_45540
    }
if(reqDto!=null){
      addTimerTaskPlanComReqDto.setObjectId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1041780_1_45540
addTimerTaskPlanComReqDto.setAddRuleInfoId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1041783_1_45540
addTimerTaskPlanComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1041797_1_45540
addTimerTaskPlanComReqDto.setStandbyField1(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1041781_1_45540
    }
if(obtainExecuteProgressComRespDto!=null){
      addTimerTaskPlanComReqDto.setStandbyField2(obtainExecuteProgressComRespDto.getExecuteProgressId());//SimpleFieldAssign//sourceId:1041798_1_45540
    }

    /*D3新增定时任务调度(公共)[4995]   */
    Assert.isNull(addTimerTaskPlanComReqDto.getCycleStandardName(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-周期名称不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getTargetContentName(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-目标内容名称不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getIsCompensateTask(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否补偿任务不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getDispatchActionTypeCode(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-任务调度的行为类型编码不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getTaskDispatchTypeCode(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-任务调度类型编码不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getObjectTypeCode(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-归属对象类型编码不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getObjectId(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-归属对象内容ID不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getAddRuleInfoTypeCode(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-生成规则信息类型编码不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getAddRuleInfoId(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-生成辅助规则信息值不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentTypeCode(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-主题内容类型编码不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentId(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-主题内容ID不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getStandbyField1(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-备用字段1不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getStandbyField2(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-备用字段2不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getIsAppointSimpleMq(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否固化消息队列不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getIsComplete(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否执行完成不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getIsRealTimeaSync(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否实时异步调度不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getOperationInductionId(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-操作人就职记录ID不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getSpaceId(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-创建于空间ID不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getAppId(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-创建于联盟应用ID不能为空",false);
      addTimerTaskPlanComRespDto = taskGenService.addTimerTaskPlanCom(addTimerTaskPlanComReqDto)/*vcase invoke isSameApp*/;



           }
//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes = null;
    if(addTimerTaskPlanComRespDto !=null){
          ImplementAcceptFieldReqDto receptionServiceReq=new ImplementAcceptFieldReqDto();
  if(addTimerTaskPlanComRespDto!=null){
      receptionServiceReq.setTimingTaskDispatchId(addTimerTaskPlanComRespDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:1042720_1_45555
    }

    /*出参字段：定时任务调度ID[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTimingTaskDispatchId(),"D3-新增托底网格计算调度(公共)-出参字段：定时任务调度ID-定时任务调度记录ID不能为空",false);
      receptionServiceRes = nbGridCalculate.implementAcceptField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else{
       //else  45556

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
    if(omsTargetTimingTaskDispatch !=null){
          ImplementAcceptFieldReqDto receptionServiceReq_1=new ImplementAcceptFieldReqDto();
  if(omsTargetTimingTaskDispatch!=null){
      receptionServiceReq_1.setTimingTaskDispatchId(omsTargetTimingTaskDispatch.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:1042720_1_45557
    }

    /*出参字段：定时任务调度ID[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getTimingTaskDispatchId(),"D3-新增托底网格计算调度(公共)-出参字段：定时任务调度ID-定时任务调度记录ID不能为空",false);
      receptionServiceRes_2 = nbGridCalculate.implementAcceptField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
AddUnderpinningCalcGridDispatchComRespDto retData = new AddUnderpinningCalcGridDispatchComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setTimingTaskDispatchId(receptionServiceRes_1.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:1042721_1
    }




return retData;
  }
/**
   * D3-新增托底网格计算调度(公共)[7215]
   * gen by moon at 6/26/2023, 10:30:38 PM
   */
  @Trace(operationName = "D3-新增托底网格计算调度(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddUnderCalcGridDispatchComRespDto addUnderCalcGridDispatchCom(AddUnderCalcGridDispatchComReqDto reqDto){




      Boolean bLock = false;
      String key = "";
      ImplementAcceptFieldRespDto receptionServiceRes_1 =null;
      try{

//virtualUsage D3获取执行进度信息(公共)  45554
          ObtainStatisticsUpdateExecuteProgressComRespDto obtainStatisticsUpdateExecuteProgressComRespDto = null;
          ObtainStatisticsUpdateExecuteProgressComReqDto obtainStatisticsUpdateExecuteProgressComReqDto=new ObtainStatisticsUpdateExecuteProgressComReqDto();
          obtainStatisticsUpdateExecuteProgressComReqDto.setObjectTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1042708_1_45554
          obtainStatisticsUpdateExecuteProgressComReqDto.setUseTypeCode("USE_ALL_TEMP_CALCULATE");//CUSTOM_CONVENTION//sourceId:1042710_1_45554
          obtainStatisticsUpdateExecuteProgressComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1042716_1_45554
          obtainStatisticsUpdateExecuteProgressComReqDto.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1042712_1_45554
          obtainStatisticsUpdateExecuteProgressComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1042714_1_45554
          obtainStatisticsUpdateExecuteProgressComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:1042715_1_45554
          if(reqDto!=null){
              obtainStatisticsUpdateExecuteProgressComReqDto.setObjectId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1042709_1_45554
              obtainStatisticsUpdateExecuteProgressComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1042711_1_45554
          }

          /*D3获取执行进度信息(公共)[7207]   */
          Assert.isNull(obtainStatisticsUpdateExecuteProgressComReqDto.getObjectTypeCode(),"D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-归属对象类型编码不能为空",false);
          Assert.isNull(obtainStatisticsUpdateExecuteProgressComReqDto.getObjectId(),"D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-归属对象内容ID不能为空",false);
          Assert.isNull(obtainStatisticsUpdateExecuteProgressComReqDto.getUseTypeCode(),"D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-用途类型编码不能为空",false);
          Assert.isNull(obtainStatisticsUpdateExecuteProgressComReqDto.getThemeContentTypeCode(),"D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-主题内容类型编码不能为空",false);
          Assert.isNull(obtainStatisticsUpdateExecuteProgressComReqDto.getThemeContentId(),"D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-主题内容ID不能为空",false);
          Assert.isNull(obtainStatisticsUpdateExecuteProgressComReqDto.getOperationInductionId(),"D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-操作人就职记录ID不能为空",false);
          Assert.isNull(obtainStatisticsUpdateExecuteProgressComReqDto.getSpaceId(),"D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-创建于空间ID不能为空",false);
          Assert.isNull(obtainStatisticsUpdateExecuteProgressComReqDto.getAppId(),"D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-创建于联盟应用ID不能为空",false);
          obtainStatisticsUpdateExecuteProgressComRespDto = executeProgressService.obtainStatisticsUpdateExecuteProgressCom(obtainStatisticsUpdateExecuteProgressComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage 3-2-09查询定时任务调度列表  45935
          List<OmsTargetTimingTaskDispatch> listOmsTargetTimingTaskDispatch =new ArrayList<>();
          QueryTimerTaskPlanListReq queryTimerTaskPlanListReq=new QueryTimerTaskPlanListReq();
          queryTimerTaskPlanListReq.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:1053130_1_45935
          queryTimerTaskPlanListReq.setDispatchActionTypeCode("DISPATCH_EXECUTE_GRID_CALC_TASK");//sourceId:1053131_1_45935
          queryTimerTaskPlanListReq.setIsComplete("FALSE");//sourceId:1053133_1_45935
          queryTimerTaskPlanListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1053137_1_45935
          if(reqDto!=null){
      queryTimerTaskPlanListReq.setObjectId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1053136_1_45935
              queryTimerTaskPlanListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1053146_1_45935
          }

          /*3-2-09查询定时任务调度列表[3261]   */
          Assert.isNull(queryTimerTaskPlanListReq.getTaskDispatchTypeCode(),"D3-新增托底网格计算调度(公共)-3-2-09查询定时任务调度列表-任务调度类型编码不能为空",false);
          Assert.isNull(queryTimerTaskPlanListReq.getDispatchActionTypeCode(),"D3-新增托底网格计算调度(公共)-3-2-09查询定时任务调度列表-任务调度的行为类型编码不能为空",false);
          Assert.isNull(queryTimerTaskPlanListReq.getObjectId(),"D3-新增托底网格计算调度(公共)-3-2-09查询定时任务调度列表-归属对象内容ID不能为空",false);
          Assert.isNull(queryTimerTaskPlanListReq.getThemeContentId(),"D3-新增托底网格计算调度(公共)-3-2-09查询定时任务调度列表-主题内容ID不能为空",false);
          Assert.isNull(queryTimerTaskPlanListReq.getIsComplete(),"D3-新增托底网格计算调度(公共)-3-2-09查询定时任务调度列表-是否执行完成不能为空",false);
          Assert.isNull(queryTimerTaskPlanListReq.getSpaceId(),"D3-新增托底网格计算调度(公共)-3-2-09查询定时任务调度列表-创建于空间ID不能为空",false);
          listOmsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanList(queryTimerTaskPlanListReq)/*vcase invoke 本地 method 方法调用;*/;



          if((listOmsTargetTimingTaskDispatch!= null&&  listOmsTargetTimingTaskDispatch !=null && listOmsTargetTimingTaskDispatch.size()==0)) {
              //if(3-2-09查未完成的全网格计算标准数据调度列表.定时任务调度列表数据集条数 等于 0)  45936

              ObtainLockSemanticInstanceComRespDto obtainLockSemanticInstanceComRespDto = null;
              ObtainLockSemanticInstanceComReqDto obtainLockSemanticInstanceComReqDto=new ObtainLockSemanticInstanceComReqDto();
              obtainLockSemanticInstanceComReqDto.setTemplateSemanticEngineCode("ADD_TEMP_ALL_CONTENT_CALC_LOCK_KEY");//CUSTOM_CONVENTION//sourceId:1065135_1_46380
              if(reqDto!=null){
                  obtainLockSemanticInstanceComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1065137_1_46380
              }

              /*D2获取分布式锁语义实例(公共)[7255]   */
              Assert.isNull(obtainLockSemanticInstanceComReqDto.getTemplateSemanticEngineCode(),"D3-新增托底网格计算调度(公共)-D2获取分布式锁语义实例(公共)-模板引擎标识不能为空",false);
              Assert.isNull(obtainLockSemanticInstanceComReqDto.getEvaluationTemplateId(),"D3-新增托底网格计算调度(公共)-D2获取分布式锁语义实例(公共)-冗余评价模板ID不能为空",false);
              obtainLockSemanticInstanceComRespDto = fwCompTemplateEngineClient.obtainLockSemanticInstanceCom(obtainLockSemanticInstanceComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;

              key = obtainLockSemanticInstanceComRespDto.getObjectName();

              ImplementDistributedLockingComRespDto implementDistributedLockingComRespDto = null;
              if(obtainLockSemanticInstanceComRespDto !=null){
                  ImplementDistributedLockingComReqDto implementDistributedLockingComReqDto=new ImplementDistributedLockingComReqDto();
                  implementDistributedLockingComReqDto.setDuration(Long.valueOf(120));//CUSTOM_CONVENTION//sourceId:1065132_1_46375
                  if(obtainLockSemanticInstanceComRespDto!=null){
                      implementDistributedLockingComReqDto.setCommPrimaryKey(obtainLockSemanticInstanceComRespDto.getObjectName());//SimpleFieldAssign//sourceId:1065133_1_46375
                  }

                  /*D3分布式加锁(公共)[7253]   */
                  Assert.isNull(implementDistributedLockingComReqDto.getCommPrimaryKey(),"D3-新增托底网格计算调度(公共)-D3分布式加锁(公共)-通用主键ID不能为空",false);
                  Assert.isNull(implementDistributedLockingComReqDto.getDuration(),"D3-新增托底网格计算调度(公共)-D3分布式加锁(公共)-锁定时长不能为空",false);
                  implementDistributedLockingComRespDto = interfaceModeService.implementDistributedLockingCom(implementDistributedLockingComReqDto)/*vcase invoke isSameApp*/;



              }
              if((implementDistributedLockingComRespDto!= null&&  implementDistributedLockingComRespDto.getTureOrFalse() !=null && implementDistributedLockingComRespDto.getTureOrFalse().equals("TRUE"))) {
                  //if(D3分布式加锁(公共).加锁是否成功 等于 是)  46376

                  bLock = true;
                  OmsEvaluationTemplate omsEvaluationTemplate = null;
                  QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
                  queryEvaTempDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1041895_1_46381
                  if(reqDto!=null){
                      queryEvaTempDetailReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1041922_1_46381
                      queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1041894_1_46381
                  }

                  /*3-2-02查评价模板简称[2316]   */
                  Assert.isNull(queryEvaTempDetailReq.getTargetId(),"D3-新增托底网格计算调度(公共)-3-2-02查评价模板简称-对应的目标ID不能为空",false);
                  Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(),"D3-新增托底网格计算调度(公共)-3-2-02查评价模板简称-评价模板ID不能为空",false);
                  Assert.isNull(queryEvaTempDetailReq.getSubjectLifeCycle(),"D3-新增托底网格计算调度(公共)-3-2-02查评价模板简称-主体生命周期不能为空",false);
                  omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;



                  OmsExecuteCycleStage omsExecuteCycleStage = null;
                  QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();
                  queryExecuteCycleStageDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1049626_1_46382
                  if(reqDto!=null){
                      queryExecuteCycleStageDetailReq.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1049624_1_46382
                  }

                  /*3-3-07查执行周期阶段名称（用于增调度使用）[2429]   */
                  Assert.isNull(queryExecuteCycleStageDetailReq.getExecuteCycleStageId(),"D3-新增托底网格计算调度(公共)-3-3-07查执行周期阶段名称（用于增调度使用）-执行周期阶段ID不能为空",false);
                  Assert.isNull(queryExecuteCycleStageDetailReq.getSpaceId(),"D3-新增托底网格计算调度(公共)-3-3-07查执行周期阶段名称（用于增调度使用）-创建于空间ID不能为空",false);
                  omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;



                  AddTimerTaskPlanComRespDto addTimerTaskPlanComRespDto = null;
    if(omsExecuteCycleStage !=null&&omsEvaluationTemplate !=null&&obtainStatisticsUpdateExecuteProgressComRespDto !=null){
                      AddTimerTaskPlanComReqDto addTimerTaskPlanComReqDto=new AddTimerTaskPlanComReqDto();
                      addTimerTaskPlanComReqDto.setIsCompensateTask("FALSE");//sourceId:1041776_1_46383
                      addTimerTaskPlanComReqDto.setDispatchActionTypeCode("DISPATCH_EXECUTE_GRID_CALC_TASK");//sourceId:1041777_1_46383
                      addTimerTaskPlanComReqDto.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:1041778_1_46383
                      addTimerTaskPlanComReqDto.setObjectTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1041779_1_46383
                      addTimerTaskPlanComReqDto.setAddRuleInfoTypeCode("OMS_CYCLE");//sourceId:1041782_1_46383
                      addTimerTaskPlanComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1041796_1_46383
                      addTimerTaskPlanComReqDto.setIsAppointSimpleMq("FALSE");//sourceId:1041793_1_46383
                      addTimerTaskPlanComReqDto.setIsComplete("FALSE");//sourceId:1041791_1_46383
                      addTimerTaskPlanComReqDto.setIsRealTimeaSync("TRUE");//sourceId:1041802_1_46383
                      addTimerTaskPlanComReqDto.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1041788_1_46383
                      addTimerTaskPlanComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1041789_1_46383
                      addTimerTaskPlanComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:1041790_1_46383
                      if(omsExecuteCycleStage!=null){
                          addTimerTaskPlanComReqDto.setCycleStandardName(omsExecuteCycleStage.getCycleStandardName());//SimpleFieldAssign//sourceId:1041957_1_46383
                      }
                      if(omsEvaluationTemplate!=null){
                          addTimerTaskPlanComReqDto.setTargetContentName(omsEvaluationTemplate.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:1041956_1_46383
                      }
                      if(reqDto!=null){
                          addTimerTaskPlanComReqDto.setObjectId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1041780_1_46383
                          addTimerTaskPlanComReqDto.setAddRuleInfoId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1041783_1_46383
                          addTimerTaskPlanComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1041797_1_46383
addTimerTaskPlanComReqDto.setStandbyField1(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1041781_1_46383
                          addTimerTaskPlanComReqDto.setStandbyField3(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1049628_1_46383
                          addTimerTaskPlanComReqDto.setStandbyField4(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1059220_1_46383
                      }
                      if(obtainStatisticsUpdateExecuteProgressComRespDto!=null){
                          addTimerTaskPlanComReqDto.setStandbyField2(obtainStatisticsUpdateExecuteProgressComRespDto.getExecuteProgressId());//SimpleFieldAssign//sourceId:1041798_1_46383
                      }

                      /*D3新增定时任务调度(公共)[4995]   */
                      Assert.isNull(addTimerTaskPlanComReqDto.getCycleStandardName(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-周期名称不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto.getTargetContentName(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-目标内容名称不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto.getIsCompensateTask(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否补偿任务不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto.getDispatchActionTypeCode(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-任务调度的行为类型编码不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto.getTaskDispatchTypeCode(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-任务调度类型编码不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto.getObjectTypeCode(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-归属对象类型编码不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto.getObjectId(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-归属对象内容ID不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto.getAddRuleInfoTypeCode(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-生成规则信息类型编码不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto.getAddRuleInfoId(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-生成辅助规则信息值不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentTypeCode(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-主题内容类型编码不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentId(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-主题内容ID不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto.getStandbyField1(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-备用字段1不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto.getStandbyField2(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-备用字段2不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto.getStandbyField3(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-备用字段3不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto.getIsAppointSimpleMq(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否固化消息队列不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto.getIsComplete(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否执行完成不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto.getIsRealTimeaSync(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否实时异步调度不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto.getOperationInductionId(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-操作人就职记录ID不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto.getSpaceId(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-创建于空间ID不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto.getAppId(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-创建于联盟应用ID不能为空",false);
                      addTimerTaskPlanComRespDto = taskGenService.addTimerTaskPlanCom(addTimerTaskPlanComReqDto)/*vcase invoke isSameApp*/;



                  }
//ModelCode: receptionService
                  ImplementAcceptFieldRespDto receptionServiceRes = null;
                  if(addTimerTaskPlanComRespDto !=null){
                      ImplementAcceptFieldReqDto receptionServiceReq=new ImplementAcceptFieldReqDto();
                      if(addTimerTaskPlanComRespDto!=null){
                          receptionServiceReq.setTimingTaskDispatchId(addTimerTaskPlanComRespDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:1042720_1_46384
                      }

                      /*出参字段：定时任务调度ID[6100]  用于特殊方法接收上游入参。 */
                      Assert.isNull(receptionServiceReq.getTimingTaskDispatchId(),"D3-新增托底网格计算调度(公共)-出参字段：定时任务调度ID-定时任务调度记录ID不能为空",false);
                      receptionServiceRes = nbGridCalculate.implementAcceptField(receptionServiceReq);


                      receptionServiceRes_1 = receptionServiceRes;
                  }
                  ImplementDistributedUnlockingComRespDto implementDistributedUnlockingComRespDto = null;
                  if(obtainLockSemanticInstanceComRespDto !=null){
                      ImplementDistributedUnlockingComReqDto implementDistributedUnlockingComReqDto=new ImplementDistributedUnlockingComReqDto();
                      if(obtainLockSemanticInstanceComRespDto!=null){
                          implementDistributedUnlockingComReqDto.setCommPrimaryKey(obtainLockSemanticInstanceComRespDto.getObjectName());//SimpleFieldAssign//sourceId:1065134_1_46385
                      }

                      /*D3分布式解锁(公共)[7250]   */
                      Assert.isNull(implementDistributedUnlockingComReqDto.getCommPrimaryKey(),"D3-新增托底网格计算调度(公共)-D3分布式解锁(公共)-通用主键ID不能为空",false);
                      implementDistributedUnlockingComRespDto = interfaceModeService.implementDistributedUnlockingCom(implementDistributedUnlockingComReqDto)/*vcase invoke isSameApp*/;

                     bLock = false;

                  }
              }
              else if((implementDistributedLockingComRespDto!= null&&  implementDistributedLockingComRespDto.getTureOrFalse() !=null && implementDistributedLockingComRespDto.getTureOrFalse().equals("FALSE"))){
                  //elseif(D3分布式加锁(公共).加锁是否成功 等于 否)  46377

//processBranchName:正常结束 ,processBranchId:46379

              }
          }
          else if((listOmsTargetTimingTaskDispatch!= null&&  listOmsTargetTimingTaskDispatch !=null && listOmsTargetTimingTaskDispatch.size()==1)){
              //elseif(3-2-09查未完成的全网格计算标准数据调度列表.定时任务调度列表数据集条数 等于 1)  45937

              ObtainLockSemanticInstanceComRespDto obtainLockSemanticInstanceComRespDto_2 = null;
              ObtainLockSemanticInstanceComReqDto obtainLockSemanticInstanceComReqDto_1=new ObtainLockSemanticInstanceComReqDto();
              obtainLockSemanticInstanceComReqDto_1.setTemplateSemanticEngineCode("ADD_TEMP_ALL_CONTENT_CALC_LOCK_KEY");//CUSTOM_CONVENTION//sourceId:1065135_1_46413
              if(reqDto!=null){
                  obtainLockSemanticInstanceComReqDto_1.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1065137_1_46413
              }

              /*D2获取分布式锁语义实例(公共)[7255]   */
              Assert.isNull(obtainLockSemanticInstanceComReqDto_1.getTemplateSemanticEngineCode(),"D3-新增托底网格计算调度(公共)-D2获取分布式锁语义实例(公共)-模板引擎标识不能为空",false);
              Assert.isNull(obtainLockSemanticInstanceComReqDto_1.getEvaluationTemplateId(),"D3-新增托底网格计算调度(公共)-D2获取分布式锁语义实例(公共)-冗余评价模板ID不能为空",false);
              obtainLockSemanticInstanceComRespDto_2 = fwCompTemplateEngineClient.obtainLockSemanticInstanceCom(obtainLockSemanticInstanceComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;

              key = obtainLockSemanticInstanceComRespDto_2.getObjectName();

              ImplementDistributedLockingComRespDto implementDistributedLockingComRespDto_2 = null;
              if(obtainLockSemanticInstanceComRespDto_2 !=null){
                  ImplementDistributedLockingComReqDto implementDistributedLockingComReqDto_1=new ImplementDistributedLockingComReqDto();
                  implementDistributedLockingComReqDto_1.setDuration(Long.valueOf(120));//CUSTOM_CONVENTION//sourceId:1065132_1_46414
                  if(obtainLockSemanticInstanceComRespDto_2!=null){
                      implementDistributedLockingComReqDto_1.setCommPrimaryKey(obtainLockSemanticInstanceComRespDto_2.getObjectName());//SimpleFieldAssign//sourceId:1065133_1_46414
                  }

                  /*D3分布式加锁(公共)[7253]   */
                  Assert.isNull(implementDistributedLockingComReqDto_1.getCommPrimaryKey(),"D3-新增托底网格计算调度(公共)-D3分布式加锁(公共)-通用主键ID不能为空",false);
                  Assert.isNull(implementDistributedLockingComReqDto_1.getDuration(),"D3-新增托底网格计算调度(公共)-D3分布式加锁(公共)-锁定时长不能为空",false);
                  implementDistributedLockingComRespDto_2 = interfaceModeService.implementDistributedLockingCom(implementDistributedLockingComReqDto_1)/*vcase invoke isSameApp*/;



              }
              if((implementDistributedLockingComRespDto_2!= null&&  implementDistributedLockingComRespDto_2.getTureOrFalse() !=null && implementDistributedLockingComRespDto_2.getTureOrFalse().equals("TRUE"))) {
                  //if(D3分布式加锁(公共).加锁是否成功 等于 是)  46415

                  bLock = true;
                  OmsEvaluationTemplate omsEvaluationTemplate_2 = null;
                  QueryEvaTempDetailReq queryEvaTempDetailReq_1=new QueryEvaTempDetailReq();
                  queryEvaTempDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1041895_1_46418
                  if(reqDto!=null){
                      queryEvaTempDetailReq_1.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1041922_1_46418
                      queryEvaTempDetailReq_1.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1041894_1_46418
                  }

                  /*3-2-02查评价模板简称[2316]   */
                  Assert.isNull(queryEvaTempDetailReq_1.getTargetId(),"D3-新增托底网格计算调度(公共)-3-2-02查评价模板简称-对应的目标ID不能为空",false);
                  Assert.isNull(queryEvaTempDetailReq_1.getEvaluationTemplateId(),"D3-新增托底网格计算调度(公共)-3-2-02查评价模板简称-评价模板ID不能为空",false);
                  Assert.isNull(queryEvaTempDetailReq_1.getSubjectLifeCycle(),"D3-新增托底网格计算调度(公共)-3-2-02查评价模板简称-主体生命周期不能为空",false);
                  omsEvaluationTemplate_2 = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



                  OmsExecuteCycleStage omsExecuteCycleStage_2 = null;
                  QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_1=new QueryExecuteCycleStageDetailReq();
                  queryExecuteCycleStageDetailReq_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1049626_1_46419
                  if(reqDto!=null){
                      queryExecuteCycleStageDetailReq_1.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1049624_1_46419
                  }

                  /*3-3-07查执行周期阶段名称（用于增调度使用）[2429]   */
                  Assert.isNull(queryExecuteCycleStageDetailReq_1.getExecuteCycleStageId(),"D3-新增托底网格计算调度(公共)-3-3-07查执行周期阶段名称（用于增调度使用）-执行周期阶段ID不能为空",false);
                  Assert.isNull(queryExecuteCycleStageDetailReq_1.getSpaceId(),"D3-新增托底网格计算调度(公共)-3-3-07查执行周期阶段名称（用于增调度使用）-创建于空间ID不能为空",false);
                  omsExecuteCycleStage_2 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



                  AddTimerTaskPlanComRespDto addTimerTaskPlanComRespDto_2 = null;
    if(omsExecuteCycleStage_2 !=null&&omsEvaluationTemplate_2 !=null&&obtainStatisticsUpdateExecuteProgressComRespDto !=null){
                      AddTimerTaskPlanComReqDto addTimerTaskPlanComReqDto_1=new AddTimerTaskPlanComReqDto();
                      addTimerTaskPlanComReqDto_1.setIsCompensateTask("FALSE");//sourceId:1041776_1_46420
                      addTimerTaskPlanComReqDto_1.setDispatchActionTypeCode("DISPATCH_EXECUTE_GRID_CALC_TASK");//sourceId:1041777_1_46420
                      addTimerTaskPlanComReqDto_1.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:1041778_1_46420
                      addTimerTaskPlanComReqDto_1.setObjectTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1041779_1_46420
                      addTimerTaskPlanComReqDto_1.setAddRuleInfoTypeCode("OMS_CYCLE");//sourceId:1041782_1_46420
                      addTimerTaskPlanComReqDto_1.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1041796_1_46420
                      addTimerTaskPlanComReqDto_1.setIsAppointSimpleMq("FALSE");//sourceId:1041793_1_46420
                      addTimerTaskPlanComReqDto_1.setIsComplete("FALSE");//sourceId:1041791_1_46420
                      addTimerTaskPlanComReqDto_1.setIsRealTimeaSync("TRUE");//sourceId:1041802_1_46420
                      addTimerTaskPlanComReqDto_1.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1041788_1_46420
                      addTimerTaskPlanComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1041789_1_46420
                      addTimerTaskPlanComReqDto_1.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:1041790_1_46420
                      if(omsExecuteCycleStage_2!=null){
                          addTimerTaskPlanComReqDto_1.setCycleStandardName(omsExecuteCycleStage_2.getCycleStandardName());//SimpleFieldAssign//sourceId:1041957_1_46420
                      }
                      if(omsEvaluationTemplate_2!=null){
                          addTimerTaskPlanComReqDto_1.setTargetContentName(omsEvaluationTemplate_2.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:1041956_1_46420
                      }
                      if(reqDto!=null){
                          addTimerTaskPlanComReqDto_1.setObjectId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1041780_1_46420
                          addTimerTaskPlanComReqDto_1.setAddRuleInfoId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1041783_1_46420
                          addTimerTaskPlanComReqDto_1.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1041797_1_46420
addTimerTaskPlanComReqDto_1.setStandbyField1(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1041781_1_46420
                          addTimerTaskPlanComReqDto_1.setStandbyField3(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1049628_1_46420
                          addTimerTaskPlanComReqDto_1.setStandbyField4(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1059220_1_46420
                      }
                      if(obtainStatisticsUpdateExecuteProgressComRespDto!=null){
                          addTimerTaskPlanComReqDto_1.setStandbyField2(obtainStatisticsUpdateExecuteProgressComRespDto.getExecuteProgressId());//SimpleFieldAssign//sourceId:1041798_1_46420
                      }

                      /*D3新增定时任务调度(公共)[4995]   */
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getCycleStandardName(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-周期名称不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getTargetContentName(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-目标内容名称不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getIsCompensateTask(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否补偿任务不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getDispatchActionTypeCode(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-任务调度的行为类型编码不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getTaskDispatchTypeCode(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-任务调度类型编码不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getObjectTypeCode(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-归属对象类型编码不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getObjectId(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-归属对象内容ID不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getAddRuleInfoTypeCode(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-生成规则信息类型编码不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getAddRuleInfoId(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-生成辅助规则信息值不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getThemeContentTypeCode(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-主题内容类型编码不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getThemeContentId(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-主题内容ID不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getStandbyField1(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-备用字段1不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getStandbyField2(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-备用字段2不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getStandbyField3(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-备用字段3不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getIsAppointSimpleMq(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否固化消息队列不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getIsComplete(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否执行完成不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getIsRealTimeaSync(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否实时异步调度不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getOperationInductionId(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-操作人就职记录ID不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getSpaceId(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-创建于空间ID不能为空",false);
                      Assert.isNull(addTimerTaskPlanComReqDto_1.getAppId(),"D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-创建于联盟应用ID不能为空",false);
                      addTimerTaskPlanComRespDto_2 = taskGenService.addTimerTaskPlanCom(addTimerTaskPlanComReqDto_1)/*vcase invoke isSameApp*/;



                  }
//ModelCode: receptionService
                  ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
                  if(addTimerTaskPlanComRespDto_2 !=null){
                      ImplementAcceptFieldReqDto receptionServiceReq_1=new ImplementAcceptFieldReqDto();
                      if(addTimerTaskPlanComRespDto_2!=null){
                          receptionServiceReq_1.setTimingTaskDispatchId(addTimerTaskPlanComRespDto_2.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:1042720_1_46421
                      }

                      /*出参字段：定时任务调度ID[6100]  用于特殊方法接收上游入参。 */
                      Assert.isNull(receptionServiceReq_1.getTimingTaskDispatchId(),"D3-新增托底网格计算调度(公共)-出参字段：定时任务调度ID-定时任务调度记录ID不能为空",false);
                      receptionServiceRes_2 = nbGridCalculate.implementAcceptField(receptionServiceReq_1);


                      receptionServiceRes_1 = receptionServiceRes_2;
                  }
                  ImplementDistributedUnlockingComRespDto implementDistributedUnlockingComRespDto_1 = null;
                  if(obtainLockSemanticInstanceComRespDto_2 !=null){
                      ImplementDistributedUnlockingComReqDto implementDistributedUnlockingComReqDto_1=new ImplementDistributedUnlockingComReqDto();
                      if(obtainLockSemanticInstanceComRespDto_2!=null){
                          implementDistributedUnlockingComReqDto_1.setCommPrimaryKey(obtainLockSemanticInstanceComRespDto_2.getObjectName());//SimpleFieldAssign//sourceId:1065134_1_46422
                      }

                      /*D3分布式解锁(公共)[7250]   */
                      Assert.isNull(implementDistributedUnlockingComReqDto_1.getCommPrimaryKey(),"D3-新增托底网格计算调度(公共)-D3分布式解锁(公共)-通用主键ID不能为空",false);
                      implementDistributedUnlockingComRespDto_1 = interfaceModeService.implementDistributedUnlockingCom(implementDistributedUnlockingComReqDto_1)/*vcase invoke isSameApp*/;
                      bLock = false;


                  }
              }
              else if((implementDistributedLockingComRespDto_2!= null&&  implementDistributedLockingComRespDto_2.getTureOrFalse() !=null && implementDistributedLockingComRespDto_2.getTureOrFalse().equals("FALSE"))){
                  //elseif(D3分布式加锁(公共).加锁是否成功 等于 否)  46416

//processBranchName:正常结束 ,processBranchId:46417

              }
          }
          else if((listOmsTargetTimingTaskDispatch!= null&&  listOmsTargetTimingTaskDispatch !=null && listOmsTargetTimingTaskDispatch.size()>=2)){
              //elseif(3-2-09查未完成的全网格计算标准数据调度列表.定时任务调度列表数据集条数 大于等于 2)  45957

              CalculateOldestOfMultipleNumComRespDto calculateOldestOfMultipleNumComRespDto = null;
              if(listOmsTargetTimingTaskDispatch !=null&& !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch)&& listOmsTargetTimingTaskDispatch.size()>0 ){
                  CalculateOldestOfMultipleNumComReqDto calculateOldestOfMultipleNumComReqDto=new CalculateOldestOfMultipleNumComReqDto();
                  if(listOmsTargetTimingTaskDispatch!= null&& !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch)&&  listOmsTargetTimingTaskDispatch !=null&& !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch)){
                      calculateOldestOfMultipleNumComReqDto.setOldestOfMultipleNumList(//objList-to-objLists
                              listOmsTargetTimingTaskDispatch.stream().map(item -> {
                                  OldestOfMultipleNumDto elm = new OldestOfMultipleNumDto();
                                  elm.setCommPrimaryKey(item.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:222498_2_45967
                                  elm.setComTimeField(item.getCreateTime());//SimpleFieldAssign//sourceId:222499_2_45967
                                  return elm;
                              }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1053157_1_45967
                  }

                  /*D4-计算数据集取最早(公共)[7233]   */

                  calculateOldestOfMultipleNumComRespDto = fwCalcCalculationRulesClient.calculateOldestOfMultipleNumCom(calculateOldestOfMultipleNumComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



              }
//ModelCode: receptionService
              ImplementAcceptFieldRespDto receptionServiceRes_3 = null;
              if(calculateOldestOfMultipleNumComRespDto !=null){
                  ImplementAcceptFieldReqDto receptionServiceReq_2=new ImplementAcceptFieldReqDto();
                  if(calculateOldestOfMultipleNumComRespDto!=null){
                      receptionServiceReq_2.setTimingTaskDispatchId(calculateOldestOfMultipleNumComRespDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1042720_1_45968
                  }

                  /*出参字段：定时任务调度ID[6100]  用于特殊方法接收上游入参。 */
                  Assert.isNull(receptionServiceReq_2.getTimingTaskDispatchId(),"D3-新增托底网格计算调度(公共)-出参字段：定时任务调度ID-定时任务调度记录ID不能为空",false);
                  receptionServiceRes_3 = nbGridCalculate.implementAcceptField(receptionServiceReq_2);


                  receptionServiceRes_1 = receptionServiceRes_3;
              }
          }
      }finally {
          if(bLock){
              ImplementDistributedUnlockingComReqDto implementDistributedUnlockingComReqDto=new ImplementDistributedUnlockingComReqDto();
              implementDistributedUnlockingComReqDto.setCommPrimaryKey(key);
              interfaceModeService.implementDistributedUnlockingCom(implementDistributedUnlockingComReqDto)/*vcase invoke isSameApp*/;
          }
      }


AddUnderCalcGridDispatchComRespDto retData = new AddUnderCalcGridDispatchComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setTimingTaskDispatchId(receptionServiceRes_1.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:1042721_1
    }




return retData;
  }
/**
   * D3-执行获取目标内容子周期(公共)[7120]
   * gen by moon at 10/13/2023, 12:02:18 AM
   */
  @Trace(operationName = "D3-执行获取目标内容子周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementFindSubTargetCycleComRespDto implementFindSubTargetCycleCom(ImplementFindSubTargetCycleComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 =null;
if((reqDto!= null&&  reqDto.getStandardDataCalcCycleModel() !=null && reqDto.getStandardDataCalcCycleModel().equals("MID_CYCLE")||reqDto!= null&&  reqDto.getStandardDataCalcCycleModel() !=null && reqDto.getStandardDataCalcCycleModel().equals("PARENT_CYCLE"))) {
        //if((D3-执行获取目标内容子周期(公共).标准数据计算周期模型 等于 中期 or D3-执行获取目标内容子周期(公共).标准数据计算周期模型 等于 父周期))  44056

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1049841_1_44058
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1005760_1_44058
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1005761_1_44058
    }

    /*3-3-09查目标周期详情（获取树&内容信息）[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3-执行获取目标内容子周期(公共)-3-3-09查目标周期详情（获取树&内容信息）-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-执行获取目标内容子周期(公共)-3-3-09查目标周期详情（获取树&内容信息）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3-执行获取目标内容子周期(公共)-3-3-09查目标周期详情（获取树&内容信息）-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



ObtainCurrentTargetContexeCuteCycleComRespDto obtainCurrentTargetContexeCuteCycleComRespDto = null;
  if(omsEvaluationObjectTargetCycle!=null){
          ObtainCurrentTargetContexeCuteCycleComReqDto obtainCurrentTargetContexeCuteCycleComReqDto=new ObtainCurrentTargetContexeCuteCycleComReqDto();
if(reqDto!=null){
      obtainCurrentTargetContexeCuteCycleComReqDto.setCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1170161_1_49903
obtainCurrentTargetContexeCuteCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1170164_1_49903
           }
if(omsEvaluationObjectTargetCycle!=null){
      obtainCurrentTargetContexeCuteCycleComReqDto.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1170162_1_49903
obtainCurrentTargetContexeCuteCycleComReqDto.setTargetId(omsEvaluationObjectTargetCycle.getTargetId());//SimpleFieldAssign//sourceId:1170163_1_49903
    }

    /*D3获取当前目标内容执行周期(公共)[7501]   */
    Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getCycleId(),"D3-执行获取目标内容子周期(公共)-D3获取当前目标内容执行周期(公共)-周期ID不能为空",false);
Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getTargetCycleContentId(),"D3-执行获取目标内容子周期(公共)-D3获取当前目标内容执行周期(公共)-关联目标内容ID不能为空",false);
Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getTargetId(),"D3-执行获取目标内容子周期(公共)-D3获取当前目标内容执行周期(公共)-冗余目标ID不能为空",false);
Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getEvaluationTemplateId(),"D3-执行获取目标内容子周期(公共)-D3获取当前目标内容执行周期(公共)-冗余评价模板ID不能为空",false);
      obtainCurrentTargetContexeCuteCycleComRespDto = executeCycleService.obtainCurrentTargetContexeCuteCycleCom(obtainCurrentTargetContexeCuteCycleComReqDto)/*vcase invoke isSameApp*/;



           }
OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
    if(omsEvaluationObjectTargetCycle !=null&&obtainCurrentTargetContexeCuteCycleComRespDto !=null){
          QueryTargetCycleByStartAndEndTimeDetailReq queryTargetCycleByStartAndEndTimeDetailReq=new QueryTargetCycleByStartAndEndTimeDetailReq();
  queryTargetCycleByStartAndEndTimeDetailReq.setIsSubCycle("TRUE");//sourceId:1051529_1_44062
  queryTargetCycleByStartAndEndTimeDetailReq.setIsArchive("FALSE");//sourceId:1006045_1_44062
if(omsEvaluationObjectTargetCycle!=null){
      queryTargetCycleByStartAndEndTimeDetailReq.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1006037_1_44062
queryTargetCycleByStartAndEndTimeDetailReq.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1006038_1_44062
queryTargetCycleByStartAndEndTimeDetailReq.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1051528_1_44062
    }
if(obtainCurrentTargetContexeCuteCycleComRespDto!=null){
      queryTargetCycleByStartAndEndTimeDetailReq.setCycleStartTime(obtainCurrentTargetContexeCuteCycleComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1006041_1_44062
queryTargetCycleByStartAndEndTimeDetailReq.setCycleEndTime(obtainCurrentTargetContexeCuteCycleComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1006042_1_44062
    }
if(reqDto!=null){
      queryTargetCycleByStartAndEndTimeDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1006043_1_44062
    }

    /*3-3-09查目标子周期By开始与结束时间[6551]   */
    Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getEvaObjEntityId(),"D3-执行获取目标内容子周期(公共)-3-3-09查目标子周期By开始与结束时间-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getEvaObjTypeCode(),"D3-执行获取目标内容子周期(公共)-3-3-09查目标子周期By开始与结束时间-被评对象类型编码不能为空",false);
Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getTargetCycleContentId(),"D3-执行获取目标内容子周期(公共)-3-3-09查目标子周期By开始与结束时间-关联目标内容ID不能为空",false);
Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getCycleStartTime(),"D3-执行获取目标内容子周期(公共)-3-3-09查目标子周期By开始与结束时间-目标计划开始时间不能为空",false);
Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getCycleEndTime(),"D3-执行获取目标内容子周期(公共)-3-3-09查目标子周期By开始与结束时间-目标计划结束时间不能为空",false);
Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getIsSubCycle(),"D3-执行获取目标内容子周期(公共)-3-3-09查目标子周期By开始与结束时间-是否子周期不能为空",false);
Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getEvaluationTemplateId(),"D3-执行获取目标内容子周期(公共)-3-3-09查目标子周期By开始与结束时间-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getIsArchive(),"D3-执行获取目标内容子周期(公共)-3-3-09查目标子周期By开始与结束时间-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryTargetCycleByStartAndEndTimeDetail(queryTargetCycleByStartAndEndTimeDetailReq)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    if(omsEvaluationObjectTargetCycle_2 !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  if(omsEvaluationObjectTargetCycle_2!=null){
      receptionServiceReq.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1006016_1_44063
    }

    /*约定出参：更新周期对应的目标周期ID[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(),"D3-执行获取目标内容子周期(公共)-约定出参：更新周期对应的目标周期ID-被评对象目标周期ID不能为空",false);
      receptionServiceRes = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((reqDto!= null&&  reqDto.getStandardDataCalcCycleModel() !=null && reqDto.getStandardDataCalcCycleModel().equals("LAST_CYCLE")||reqDto!= null&&  reqDto.getStandardDataCalcCycleModel() !=null && reqDto.getStandardDataCalcCycleModel().equals("MID_OF_PROCESS_CYCLE")||reqDto!= null&&  reqDto.getStandardDataCalcCycleModel() !=null && reqDto.getStandardDataCalcCycleModel().equals("SUB_CYCLE"))){
       //elseif((D3-执行获取目标内容子周期(公共).标准数据计算周期模型 等于 末级周期 or D3-执行获取目标内容子周期(公共).标准数据计算周期模型 等于 中间周期 or D3-执行获取目标内容子周期(公共).标准数据计算周期模型 等于 子周期))  44057

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  if(reqDto!=null){
      receptionServiceReq_1.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1006016_1_44059
    }

    /*约定出参：更新周期对应的目标周期ID[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getEvaObjTargetCycleId(),"D3-执行获取目标内容子周期(公共)-约定出参：更新周期对应的目标周期ID-被评对象目标周期ID不能为空",false);
      receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
    }
ImplementFindSubTargetCycleComRespDto retData = new ImplementFindSubTargetCycleComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setEvaObjTargetCycleId(receptionServiceRes_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1006110_1
    }




return retData;
  }

/**
   * D3-执行与末级周期同体分析(公共)[7238]
   * gen by moon at 6/14/2024, 6:40:49 PM
   */
  @Trace(operationName = "D3-执行与末级周期同体分析(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAnalysisSubCycleIsLastCycleComRespDto implementAnalysisSubCycleIsLastCycleCom(ImplementAnalysisSubCycleIsLastCycleComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_7 =null;
//virtualUsage 约定：正常（当前周期为末级周期）  62273
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq.setSubCycleIsLastCycle("NORMAL");//sourceId:1572989_1_62273

    /*约定：正常（当前周期为末级周期）[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getSubCycleIsLastCycle(),"D3-执行与末级周期同体分析(公共)-约定：正常（当前周期为末级周期）-与末级周期同体类型分析结果不能为空",false);
      receptionServiceRes = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq);



//virtualUsage 约定：子周期与末级周期同体  62267
//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_1.setSubCycleIsLastCycle("SUB_CYCLE_SAME_AS_LAST_CYCLE_TYPE");//sourceId:1054697_1_62267

    /*约定：子周期与末级周期同体[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getSubCycleIsLastCycle(),"D3-执行与末级周期同体分析(公共)-约定：子周期与末级周期同体-与末级周期同体类型分析结果不能为空",false);
      receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);



//virtualUsage 约定：过程中间周期与末级周期同体  62268
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_2=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_2.setSubCycleIsLastCycle("MID_OF_PROCESS_SAME_AS_LAST_CYCLE_TYPE");//sourceId:1054699_1_62268

    /*约定：过程中间周期与末级周期同体[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getSubCycleIsLastCycle(),"D3-执行与末级周期同体分析(公共)-约定：过程中间周期与末级周期同体-与末级周期同体类型分析结果不能为空",false);
      receptionServiceRes_4 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_2);



if((reqDto!= null&&  reqDto.getSecondLastCycleType() !=null && reqDto.getSecondLastCycleType().equals("DISABLE"))) {
        //if(D3-执行与末级周期同体分析(公共).第二末级周期类型 等于 不启用)  62259

ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto = null;
    ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto=new ImplementStringEfficiencyCheckComReqDto();
  if(reqDto!=null){
      implementStringEfficiencyCheckComReqDto.setReferenceString(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1054077_1_62261
implementStringEfficiencyCheckComReqDto.setComparisonString(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:1054078_1_62261
    }

    /*D2-执行字符串对比(公共)[5774]   */
    Assert.isNull(implementStringEfficiencyCheckComReqDto.getReferenceString(),"D3-执行与末级周期同体分析(公共)-D2-执行字符串对比(公共)-参照字符串不能为空",false);
      implementStringEfficiencyCheckComRespDto = fwCompInterfaceModeClient.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((implementStringEfficiencyCheckComRespDto!= null&&  implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("TRUE"))) {
        //if(D2-判断当前周期类型是否等于末级周期类型.字符串对比结果 等于 是)  62292

ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto_2 = null;
    ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto_1=new ImplementStringEfficiencyCheckComReqDto();
  if(reqDto!=null){
      implementStringEfficiencyCheckComReqDto_1.setReferenceString(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1054077_1_62304
implementStringEfficiencyCheckComReqDto_1.setComparisonString(reqDto.getSubcycleType());//SimpleFieldAssign//sourceId:1054078_1_62304
    }

    /*D2-执行字符串对比(公共)[5774]   */
    Assert.isNull(implementStringEfficiencyCheckComReqDto_1.getReferenceString(),"D3-执行与末级周期同体分析(公共)-D2-执行字符串对比(公共)-参照字符串不能为空",false);
      implementStringEfficiencyCheckComRespDto_2 = fwCompInterfaceModeClient.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



if((implementStringEfficiencyCheckComRespDto_2!= null&&  implementStringEfficiencyCheckComRespDto_2.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto_2.getStringEfficiencyCheckResult().equals("TRUE"))) {
        //if(D2-判断当前周期类型是否等于子周期类型.字符串对比结果 等于 是)  62305

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_3=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_3.setSubCycleIsLastCycle(receptionServiceRes_2.getSubCycleIsLastCycle());//SimpleFieldAssign//sourceId:1054701_1_62306
    }

    /*约定出参：与末级周期同体分析结果[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getSubCycleIsLastCycle(),"D3-执行与末级周期同体分析(公共)-约定出参：与末级周期同体分析结果-与末级周期同体类型分析结果不能为空",false);
      receptionServiceRes_6 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_3);


      receptionServiceRes_7 = receptionServiceRes_6;
      }
else if((implementStringEfficiencyCheckComRespDto_2!= null&&  implementStringEfficiencyCheckComRespDto_2.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto_2.getStringEfficiencyCheckResult().equals("FALSE"))){
       //elseif(D2-判断当前周期类型是否等于子周期类型.字符串对比结果 等于 否)  62307

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_8 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_4=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_4.setSubCycleIsLastCycle(receptionServiceRes.getSubCycleIsLastCycle());//SimpleFieldAssign//sourceId:1054701_1_62308
    }

    /*约定出参：与末级周期同体分析结果[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getSubCycleIsLastCycle(),"D3-执行与末级周期同体分析(公共)-约定出参：与末级周期同体分析结果-与末级周期同体类型分析结果不能为空",false);
      receptionServiceRes_8 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_4);


      receptionServiceRes_7 = receptionServiceRes_8;
    }
      }
else if((implementStringEfficiencyCheckComRespDto!= null&&  implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("FALSE"))){
       //elseif(D2-判断当前周期类型是否等于末级周期类型.字符串对比结果 等于 否)  62293

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_9 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_5=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_5.setSubCycleIsLastCycle(receptionServiceRes.getSubCycleIsLastCycle());//SimpleFieldAssign//sourceId:1054701_1_62303
    }

    /*约定出参：与末级周期同体分析结果[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_5.getSubCycleIsLastCycle(),"D3-执行与末级周期同体分析(公共)-约定出参：与末级周期同体分析结果-与末级周期同体类型分析结果不能为空",false);
      receptionServiceRes_9 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_5);


      receptionServiceRes_7 = receptionServiceRes_9;
    }
      }
else if((!(reqDto!= null&&  reqDto.getSecondLastCycleType() !=null && reqDto.getSecondLastCycleType().equals("DISABLE")))){
       //elseif(D3-执行与末级周期同体分析(公共).第二末级周期类型 不等于 不启用)  62260

ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto_3 = null;
    ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto_2=new ImplementStringEfficiencyCheckComReqDto();
  if(reqDto!=null){
      implementStringEfficiencyCheckComReqDto_2.setReferenceString(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1054077_1_62269
implementStringEfficiencyCheckComReqDto_2.setComparisonString(reqDto.getSecondLastCycleType());//SimpleFieldAssign//sourceId:1054078_1_62269
    }

    /*D2-执行字符串对比(公共)[5774]   */
    Assert.isNull(implementStringEfficiencyCheckComReqDto_2.getReferenceString(),"D3-执行与末级周期同体分析(公共)-D2-执行字符串对比(公共)-参照字符串不能为空",false);
      implementStringEfficiencyCheckComRespDto_3 = fwCompInterfaceModeClient.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;



if((implementStringEfficiencyCheckComRespDto_3!= null&&  implementStringEfficiencyCheckComRespDto_3.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto_3.getStringEfficiencyCheckResult().equals("TRUE"))) {
        //if(D2-判断当前周期类型是否第二末级周期类型.字符串对比结果 等于 是)  62270

OmsCycle omsCycle = null;
    QueryTimeMatchCycleDetailReq queryTimeMatchCycleDetailReq=new QueryTimeMatchCycleDetailReq();
  queryTimeMatchCycleDetailReq.setCycleStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1572998_1_62310
queryTimeMatchCycleDetailReq.setCycleEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1572999_1_62310
queryTimeMatchCycleDetailReq.setIsArchive("FALSE");//sourceId:1573002_1_62310
if(reqDto!=null){
      queryTimeMatchCycleDetailReq.setCycleTypeCode(reqDto.getSecondLastCycleType());//SimpleFieldAssign//sourceId:1573000_1_62310
    }

    /*3-4-04查询时间匹配周期详情（开始小于结束大于）[4985]   */
    Assert.isNull(queryTimeMatchCycleDetailReq.getCycleStartTime(),"D3-执行与末级周期同体分析(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-周期开始时间不能为空",false);
Assert.isNull(queryTimeMatchCycleDetailReq.getCycleEndTime(),"D3-执行与末级周期同体分析(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-周期结束时间不能为空",false);
Assert.isNull(queryTimeMatchCycleDetailReq.getCycleTypeCode(),"D3-执行与末级周期同体分析(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-周期类型标识不能为空",false);
Assert.isNull(queryTimeMatchCycleDetailReq.getIsArchive(),"D3-执行与末级周期同体分析(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-是否存档不能为空",false);
      omsCycle = mOmsCycleService.queryTimeMatchCycleDetail(queryTimeMatchCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
    if(omsCycle !=null){
          CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto=new CheckTimeScopeSearchComReqDto();
  if(omsCycle!=null){
      checkTimeScopeSearchComReqDto.setCurrentTime(omsCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:1573014_1_62311
    }
if(reqDto!=null){
      checkTimeScopeSearchComReqDto.setCompareTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1573016_1_62311
    }

    /*D2两个时间对比大小(公共)[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(),"D3-执行与末级周期同体分析(公共)-D2两个时间对比大小(公共)-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(),"D3-执行与末级周期同体分析(公共)-D2两个时间对比大小(公共)-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT")||checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("LATER"))) {
        //if((D2第二末级周期的周期开始时间与入参更新周期结束时间对比.时间比较结果 等于 当前（等于） or D2第二末级周期的周期开始时间与入参更新周期结束时间对比.时间比较结果 等于 之后（大于）))  62275

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_10 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_6=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_4!=null){
      receptionServiceReq_6.setSubCycleIsLastCycle(receptionServiceRes_4.getSubCycleIsLastCycle());//SimpleFieldAssign//sourceId:1054701_1_62312
    }

    /*约定出参：与末级周期同体分析结果[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_6.getSubCycleIsLastCycle(),"D3-执行与末级周期同体分析(公共)-约定出参：与末级周期同体分析结果-与末级周期同体类型分析结果不能为空",false);
      receptionServiceRes_10 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_6);


      receptionServiceRes_7 = receptionServiceRes_10;
      }
      }
else if((implementStringEfficiencyCheckComRespDto_3!= null&&  implementStringEfficiencyCheckComRespDto_3.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto_3.getStringEfficiencyCheckResult().equals("FALSE"))){
       //elseif(D2-判断当前周期类型是否第二末级周期类型.字符串对比结果 等于 否)  62309

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_11 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_7=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_7.setSubCycleIsLastCycle(receptionServiceRes.getSubCycleIsLastCycle());//SimpleFieldAssign//sourceId:1054701_1_62313
    }

    /*约定出参：与末级周期同体分析结果[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_7.getSubCycleIsLastCycle(),"D3-执行与末级周期同体分析(公共)-约定出参：与末级周期同体分析结果-与末级周期同体类型分析结果不能为空",false);
      receptionServiceRes_11 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_7);


      receptionServiceRes_7 = receptionServiceRes_11;
    }
    }
else{
       //else  62314

//异常结束 62315
      throw new BizException("C221000373","对不起，末级周期类型与第二末级周期类型，找不到数据了~",false);
    }
ImplementAnalysisSubCycleIsLastCycleComRespDto retData = new ImplementAnalysisSubCycleIsLastCycleComRespDto();
  if(receptionServiceRes_7!=null){
      retData.setSubCycleIsLastCycle(receptionServiceRes_7.getSubCycleIsLastCycle());//SimpleFieldAssign//sourceId:1054703_1
    }




return retData;
  }
/**
   * D3-定时计算全网内容标准数据(公共)[6378]
   * gen by moon at 6/28/2023, 1:15:06 AM
   */
  @Trace(operationName = "D3-定时计算全网内容标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public TimingCalcAllDataComRespDto timingCalcAllDataCom(TimingCalcAllDataComReqDto reqDto){


      //virtualUsage 3-2-09查询定时任务调度列表  40167
      List<OmsTargetTimingTaskDispatch> listOmsTargetTimingTaskDispatch =new ArrayList<>();
    QueryTimerTaskPlanListReq queryTimerTaskPlanListReq=new QueryTimerTaskPlanListReq();
  queryTimerTaskPlanListReq.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:899953_1_40167
queryTimerTaskPlanListReq.setDispatchActionTypeCode("DISPATCH_EXECUTE_GRID_CALC_TASK");//sourceId:899954_1_40167
queryTimerTaskPlanListReq.setObjectTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:899955_1_40167
queryTimerTaskPlanListReq.setAddRuleInfoTypeCode("OMS_CYCLE");//sourceId:899958_1_40167
queryTimerTaskPlanListReq.setIsComplete("FALSE");//sourceId:899956_1_40167
queryTimerTaskPlanListReq.setIsCompensateTask("FALSE");//sourceId:899952_1_40167

    /*3-2-09查询定时任务调度列表[3261]   */
    Assert.isNull(queryTimerTaskPlanListReq.getTaskDispatchTypeCode(),"D3-定时计算全网内容标准数据(公共)-3-2-09查询定时任务调度列表-任务调度类型编码不能为空",false);
Assert.isNull(queryTimerTaskPlanListReq.getDispatchActionTypeCode(),"D3-定时计算全网内容标准数据(公共)-3-2-09查询定时任务调度列表-任务调度的行为类型编码不能为空",false);
Assert.isNull(queryTimerTaskPlanListReq.getObjectTypeCode(),"D3-定时计算全网内容标准数据(公共)-3-2-09查询定时任务调度列表-归属对象类型编码不能为空",false);
Assert.isNull(queryTimerTaskPlanListReq.getAddRuleInfoTypeCode(),"D3-定时计算全网内容标准数据(公共)-3-2-09查询定时任务调度列表-生成规则信息类型编码不能为空",false);
Assert.isNull(queryTimerTaskPlanListReq.getIsComplete(),"D3-定时计算全网内容标准数据(公共)-3-2-09查询定时任务调度列表-是否执行完成不能为空",false);
Assert.isNull(queryTimerTaskPlanListReq.getIsCompensateTask(),"D3-定时计算全网内容标准数据(公共)-3-2-09查询定时任务调度列表-是否补偿任务不能为空",false);
      listOmsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanList(queryTimerTaskPlanListReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsTargetTimingTaskDispatch!= null&&  listOmsTargetTimingTaskDispatch !=null && listOmsTargetTimingTaskDispatch.size()>0)) {
        //if(3-2-09查询定时任务调度列表.定时任务调度列表数据集条数 大于 0)  40168

QueryAppDetailComRespDto queryAppDetailComRespDto = null;
    QueryAppDetailComReqDto queryAppDetailComReqDto=new QueryAppDetailComReqDto();
  queryAppDetailComReqDto.setAppCode("XSZ");//CUSTOM_CONVENTION//sourceId:899971_1_40169

    /*D1-2查询联盟应用详情(公共)[3268]   */

      queryAppDetailComRespDto = fwBaseBaseClient.queryAppDetailCom(queryAppDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



AddTimerTaskPlanComRespDto addTimerTaskPlanComRespDto = null;
    if(queryAppDetailComRespDto !=null){
          AddTimerTaskPlanComReqDto addTimerTaskPlanComReqDto=new AddTimerTaskPlanComReqDto();
  addTimerTaskPlanComReqDto.setIsCompensateTask("FALSE");//sourceId:900027_1_40170
addTimerTaskPlanComReqDto.setDispatchActionTypeCode("PLT_DISPATCH_EXECUTE_GRID_CALC_TASK");//sourceId:900028_1_40170
addTimerTaskPlanComReqDto.setTaskDispatchTypeCode("PROJECT_CONTROLLING_TASK");//sourceId:900029_1_40170
addTimerTaskPlanComReqDto.setObjectTypeCode("UNION_APP");//sourceId:900030_1_40170
addTimerTaskPlanComReqDto.setIsComplete("FALSE");//sourceId:900032_1_40170
addTimerTaskPlanComReqDto.setIsRealTimeaSync("TRUE");//sourceId:900033_1_40170
if(queryAppDetailComRespDto!=null){
      addTimerTaskPlanComReqDto.setObjectId(queryAppDetailComRespDto.getAppId());//SimpleFieldAssign//sourceId:1059213_1_40170
addTimerTaskPlanComReqDto.setOperationInductionId(queryAppDetailComRespDto.getOperationInductionId());//SimpleFieldAssign//sourceId:900034_1_40170
addTimerTaskPlanComReqDto.setSpaceId(queryAppDetailComRespDto.getUniqueSpaceId());//SimpleFieldAssign//sourceId:900035_1_40170
addTimerTaskPlanComReqDto.setAppId(queryAppDetailComRespDto.getAppId());//SimpleFieldAssign//sourceId:900036_1_40170
    }

    /*D3新增定时任务调度(公共)[4995]   */
    Assert.isNull(addTimerTaskPlanComReqDto.getIsCompensateTask(),"D3-定时计算全网内容标准数据(公共)-D3新增定时任务调度(公共)-是否补偿任务不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getDispatchActionTypeCode(),"D3-定时计算全网内容标准数据(公共)-D3新增定时任务调度(公共)-任务调度的行为类型编码不能为空",false);
Assert.isNull(addTimerTaskPlanComReqDto.getTaskDispatchTypeCode(),"D3-定时计算全网内容标准数据(公共)-D3新增定时任务调度(公共)-任务调度类型编码不能为空",false);
      addTimerTaskPlanComRespDto = taskGenService.addTimerTaskPlanCom(addTimerTaskPlanComReqDto)/*vcase invoke isSameApp*/;



           }
//ModelCode: circulationCollections
        for (OmsTargetTimingTaskDispatch circulationCollectionsRes: listOmsTargetTimingTaskDispatch){

ImplementUnderpinningCalcGridDispatchComRespDto implementUnderpinningCalcGridDispatchComRespDto = null;
    ImplementUnderpinningCalcGridDispatchComReqDto implementUnderpinningCalcGridDispatchComReqDto=new ImplementUnderpinningCalcGridDispatchComReqDto();
if(circulationCollectionsRes!=null){
      implementUnderpinningCalcGridDispatchComReqDto.setTimingTaskDispatchId(circulationCollectionsRes.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:1070386_1_46600
implementUnderpinningCalcGridDispatchComReqDto.setEvaluationTemplateId(circulationCollectionsRes.getObjectId());//SimpleFieldAssign//sourceId:1070387_1_46600
    }

    /*D3-执行托底网格计算调度(公共)[7216]   */

//      implementUnderpinningCalcGridDispatchComRespDto = implementUnderpinningCalcGridDispatchCom(implementUnderpinningCalcGridDispatchComReqDto)/*vcase invoke 同服务,同domain*/;



//ModelCode: circulationEnd
        }

boolean bOOLEAN ;
    if(addTimerTaskPlanComRespDto !=null){
          OmsTargetTimingTaskDispatch omsTargetTimingTaskDispatch=new OmsTargetTimingTaskDispatch();
  omsTargetTimingTaskDispatch.setIsComplete("TRUE");//sourceId:900038_1_40176
omsTargetTimingTaskDispatch.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:900039_1_40176
if(addTimerTaskPlanComRespDto!=null){
      omsTargetTimingTaskDispatch.setTimingTaskDispatchId(addTimerTaskPlanComRespDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:900037_1_40176
    }

    /*3-2-09更新定时任务调度（总控任务）[3186]   */
    Assert.isNull(omsTargetTimingTaskDispatch.getTimingTaskDispatchId(),"D3-定时计算全网内容标准数据(公共)-3-2-09更新定时任务调度（总控任务）-定时任务调度记录ID不能为空",false);
Assert.isNull(omsTargetTimingTaskDispatch.getIsComplete(),"D3-定时计算全网内容标准数据(公共)-3-2-09更新定时任务调度（总控任务）-是否执行完成不能为空",false);
Assert.isNull(omsTargetTimingTaskDispatch.getOperateTime(),"D3-定时计算全网内容标准数据(公共)-3-2-09更新定时任务调度（总控任务）-操作时间不能为空",false);
      bOOLEAN = mOmsTargetTimingTaskDispatchService.refreshTimerTaskPlan(omsTargetTimingTaskDispatch)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
TimingCalcAllDataComRespDto retData = new TimingCalcAllDataComRespDto();





return retData;
  }
/**
   * 1111D3-发布批次重计算全模板标准数据(公共)[7078]
   * gen by moon at 6/16/2024, 3:02:51 AM
   */
  @Trace(operationName = "1111D3-发布批次重计算全模板标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementReleaseRecalcEvaTempAllDataComRespDto implementReleaseRecalcEvaTempAllDataCom(ImplementReleaseRecalcEvaTempAllDataComReqDto reqDto){


      ImplementReleaseRecalcEvaTempAllDataComRespDto retData = new ImplementReleaseRecalcEvaTempAllDataComRespDto();





return retData;
  }
/**
   * D3分析汇报任务筛选父子中周期类型(公共)[7136]
   * gen by moon at 9/13/2024, 5:17:40 PM
   */
  @Trace(operationName = "D3分析汇报任务筛选父子中周期类型(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementFatherMidSubCycleAnalysisComRespDto implementFatherMidSubCycleAnalysisCom(ImplementFatherMidSubCycleAnalysisComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 =null;
//virtualUsage M3约定父中子过程周期类型  72821
      //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  receptionServiceReq.setCustomField1("PARENT_CYCLE");//CUSTOM_CONVENTION//sourceId:1999614_1_72821
receptionServiceReq.setCustomField2("MID_CYCLE");//CUSTOM_CONVENTION//sourceId:1999615_1_72821
receptionServiceReq.setCustomField3("SUB_CYCLE");//CUSTOM_CONVENTION//sourceId:1999616_1_72821
receptionServiceReq.setCustomField4("PROCESS_CYCLE");//CUSTOM_CONVENTION//sourceId:1999617_1_72821

    /*M3约定父中子过程周期类型[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D3分析汇报任务筛选父子中周期类型(公共)-M3约定父中子过程周期类型-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D3分析汇报任务筛选父子中周期类型(公共)-M3约定父中子过程周期类型-自定义字段2不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField3(),"D3分析汇报任务筛选父子中周期类型(公共)-M3约定父中子过程周期类型-自定义字段3不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField4(),"D3分析汇报任务筛选父子中周期类型(公共)-M3约定父中子过程周期类型-自定义字段4不能为空",false);
      receptionServiceRes = nbGridCalculate.implementElevenReceivingField(receptionServiceReq);



if((reqDto!= null&&  reqDto.getIsFatherCycle() !=null && reqDto.getIsFatherCycle().equals("TRUE")&&reqDto!= null&&  reqDto.getIsSubCycle() !=null && reqDto.getIsSubCycle().equals("FALSE")&&reqDto!= null&&  reqDto.getIsMetaphase() !=null && reqDto.getIsMetaphase().equals("FALSE"))) {
        //if((D3-执行父子中周期分析(公共).是否父周期 等于 是 and D3-执行父子中周期分析(公共).是否子周期 等于 否 and D3-执行父子中周期分析(公共).是否中期 等于 否))  44332

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setParentSubMidCycleType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1999186_1_44333
    }

    /*约定出参[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getParentSubMidCycleType(),"D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空",false);
      receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((reqDto!= null&&  reqDto.getIsFatherCycle() !=null && reqDto.getIsFatherCycle().equals("TRUE")&&reqDto!= null&&  reqDto.getIsSubCycle() !=null && reqDto.getIsSubCycle().equals("TRUE")&&reqDto!= null&&  reqDto.getIsMetaphase() !=null && reqDto.getIsMetaphase().equals("FALSE"))){
       //elseif((D3-执行父子中周期分析(公共).是否父周期 等于 是 and D3-执行父子中周期分析(公共).是否子周期 等于 是 and D3-执行父子中周期分析(公共).是否中期 等于 否))  44334

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_2=new CalculateAcceptAboveFieldsReqDto();
  if(reqDto!=null){
      receptionServiceReq_2.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1011202_1_44335
    }
if(receptionServiceRes!=null){
      receptionServiceReq_2.setParentSubMidCycleType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1999186_1_44335
    }

    /*约定出参[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getParentSubMidCycleType(),"D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空",false);
      receptionServiceRes_4 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
    }
else if((reqDto!= null&&  reqDto.getIsMetaphase() !=null && reqDto.getIsMetaphase().equals("TRUE")&&reqDto!= null&&  reqDto.getIsFatherCycle() !=null && reqDto.getIsFatherCycle().equals("FALSE")&&reqDto!= null&&  reqDto.getIsSubCycle() !=null && reqDto.getIsSubCycle().equals("FALSE"))){
       //elseif((D3-执行父子中周期分析(公共).是否中期 等于 是 and D3-执行父子中周期分析(公共).是否父周期 等于 否 and D3-执行父子中周期分析(公共).是否子周期 等于 否))  44336

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_3=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_3.setParentSubMidCycleType(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1999186_1_44337
    }

    /*约定出参[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getParentSubMidCycleType(),"D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空",false);
      receptionServiceRes_5 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_5;
    }
else if((reqDto!= null&&  reqDto.getIsSubCycle() !=null && reqDto.getIsSubCycle().equals("TRUE")&&reqDto!= null&&  reqDto.getIsFatherCycle() !=null && reqDto.getIsFatherCycle().equals("FALSE")&&reqDto!= null&&  reqDto.getIsMetaphase() !=null && reqDto.getIsMetaphase().equals("FALSE"))){
       //elseif((D3-执行父子中周期分析(公共).是否子周期 等于 是 and D3-执行父子中周期分析(公共).是否父周期 等于 否 and D3-执行父子中周期分析(公共).是否中期 等于 否))  72822

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_4=new CalculateAcceptAboveFieldsReqDto();
  if(reqDto!=null){
      receptionServiceReq_4.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1011202_1_72823
    }
if(receptionServiceRes!=null){
      receptionServiceReq_4.setParentSubMidCycleType(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1999186_1_72823
    }

    /*约定出参[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getParentSubMidCycleType(),"D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空",false);
      receptionServiceRes_6 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_4);


      receptionServiceRes_3 = receptionServiceRes_6;
    }
else if((reqDto!= null&&  reqDto.getIsFatherCycle() !=null && reqDto.getIsFatherCycle().equals("FALSE")&&reqDto!= null&&  reqDto.getIsSubCycle() !=null && reqDto.getIsSubCycle().equals("FALSE")&&reqDto!= null&&  reqDto.getIsMetaphase() !=null && reqDto.getIsMetaphase().equals("FALSE"))){
       //elseif((D3分析汇报任务筛选父子中周期类型(公共).是否父周期 等于 否 and D3分析汇报任务筛选父子中周期类型(公共).是否子周期 等于 否 and D3分析汇报任务筛选父子中周期类型(公共).是否中期 等于 否))  72824

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_7 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_5=new CalculateAcceptAboveFieldsReqDto();
  if(reqDto!=null){
      receptionServiceReq_5.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1011202_1_72825
    }
if(receptionServiceRes!=null){
      receptionServiceReq_5.setParentSubMidCycleType(receptionServiceRes.getCustomField4());//SimpleFieldAssign//sourceId:1999186_1_72825
    }

    /*约定出参[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_5.getParentSubMidCycleType(),"D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空",false);
      receptionServiceRes_7 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_5);


      receptionServiceRes_3 = receptionServiceRes_7;
    }
ImplementFatherMidSubCycleAnalysisComRespDto retData = new ImplementFatherMidSubCycleAnalysisComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setCycleId(receptionServiceRes_3.getCycleId());//SimpleFieldAssign//sourceId:1011207_1
retData.setParentSubMidCycleType(receptionServiceRes_3.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1999632_1
    }




return retData;
  }

  //
}
